71 #include <ti/control/mmwavelink/mmwavelink.h> 72 #include <ti/control/mmwavelink/include/rl_driver.h> 73 #include <ti/control/mmwavelink/include/rl_messages.h> 74 #include <ti/control/mmwavelink/include/rl_controller.h> 75 #include <ti/control/mmwavelink/include/rl_protocol.h> 76 #include <ti/control/mmwavelink/include/rl_trace.h> 83 #define RL_PENDING_RX_MSG(driverData, index) \ 84 (((driverData)->rxIrqCnt[(index)]) != ((driverData)->rxDoneCnt[(index)])) 87 #define RL_IF_WRITE(fd,pBuff,len) \ 88 rl_driverData.clientCtx.comIfCb.rlComIfWrite((fd),(pBuff),(len)) 89 #define RL_IF_READ(fd,pBuff,len) \ 90 rl_driverData.clientCtx.comIfCb.rlComIfRead((fd),(pBuff),(len)) 94 #define RL_IF_WRITE_CHECK(fd,pBuff,len) \ 96 if (((rlInt32_t)(len)) != RL_IF_WRITE((fd), (pBuff), (len)))\ 98 return RL_RET_CODE_RADAR_IF_ERROR;\ 101 #define RL_IF_READ_CHECK(fd,pBuff,len) \ 103 if (((rlInt32_t)(len)) != RL_IF_READ((fd), (pBuff), (len)))\ 105 return RL_RET_CODE_RADAR_IF_ERROR;\ 110 #define RL_SYNC_SCAN_THRESHOLD (252U) 113 #define RL_RHCP_HDR_OPCODE_CLASS(ptr) \ 114 (rlUInt8_t) (((rlProtHeader_t *)(ptr))->opcode.b2MsgType) 117 #define RL_RHCP_HDR_PL_LENGTH(ptr) (((rlProtHeader_t *)(ptr))->len) 119 #define PATTERN_NOT_MATCHED ((rlInt32_t)0x0) 120 #define SYNC_PATTERN_MATCHED ((rlInt32_t)0x1) 121 #define CNYS_PATTERN_MATCHED ((rlInt32_t)0x2) 124 #define D2H_SYNC_PATTERN_1 (0xDCBAU) 125 #define D2H_SYNC_PATTERN_2 (0xABCDU) 126 #define H2D_SYNC_PATTERN_1 (0x1234U) 127 #define H2D_SYNC_PATTERN_2 (0x4321U) 128 #define H2D_CNYS_PATTERN_1 (0x5678U) 129 #define H2D_CNYS_PATTERN_2 (0x8765U) 138 #pragma DATA_ALIGN(rl_driverData, 4); 144 #pragma DATA_ALIGN(rl_txMsg, 8); 146 rlRhcpMsg_t rl_txMsg[RL_CASCADE_NUM_DEVICES] = {0};
148 #pragma DATA_ALIGN(rl_rxMsg, 8); 150 rlRhcpMsg_t rl_rxMsg[RL_CASCADE_NUM_DEVICES] = {0};
156 static rlReturnVal_t rlDriverOriginDirCheck(rlUInt8_t deviceRunId, rlUInt8_t dataDir);
157 static rlUInt8_t rlDriverReceiveSync(rlComIfHdl_t comIfHdl, rlUInt8_t syncBuf[],
158 rlInt32_t *syncType);
159 static rlReturnVal_t rlDriverClientCbCheck(
rlClientCbs_t clientCb);
160 static rlReturnVal_t rlDriverOsiCbCheck(
rlClientCbs_t clientCb);
161 static rlReturnVal_t rlDriverCmdWriter(rlUInt8_t devIndex,
rlDriverMsg_t* outMsg);
184 for (shiftIdx = 0U; shiftIdx < 7U; shiftIdx++)
187 buf[shiftIdx] = buf[shiftIdx + 1U];
210 rlUInt8_t crcType, rlUInt8_t crc[RL_CRC_LEN_MAX])
212 rlReturnVal_t retVal;
214 RL_LOGV_ARG0(
"rlDriverCalCRC starts...\n");
220 retVal = rl_driverData.
clientCtx.
crcCb.rlComputeCRC(data, dataLen, crcType, &crc[0U]);
225 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
227 RL_LOGV_ARG0(
"rlDriverCalCRC ends...\n");
249 rlUInt8_t crcType, rlUInt8_t crc[RL_CRC_LEN_MAX])
252 rlUInt8_t crcByte[RL_CRC_LEN_MAX];
253 rlReturnVal_t retVal = RL_RET_CODE_OK;
255 RL_LOGV_ARG0(
"rlDriverVerifyCRC starts...\n");
258 if (RL_RET_CODE_OK != rl_driverData.
clientCtx.
crcCb.rlComputeCRC(data, dataLen, \
259 crcType, &crcByte[0U]))
262 retVal += RL_RET_CODE_RADAR_IF_ERROR;
267 for (indx = 0U; indx < (2U << crcType); indx++)
269 if (crcByte[indx] != crc[indx])
272 retVal += RL_RET_CODE_CRC_FAILED;
277 RL_LOGV_ARG0(
"rlDriverVerifyCRC ends...\n");
296 rlReturnVal_t rlDriverCalChkSum(
rlProtHeader_t* hdrData, rlUInt8_t len,
297 rlUInt16_t* checksum)
300 rlUInt32_t checkSumVal = 0U;
301 rlUInt8_t *localGenHdr = (rlUInt8_t *)hdrData;
302 rlReturnVal_t retVal;
304 RL_LOGV_ARG0(
"rlDriverCalChkSum starts...\n");
307 if (localGenHdr != RL_NULL_PTR)
317 checkSumVal += *((rlUInt16_t*) localGenHdr);
321 if ((checkSumVal & 0x80000000U) != 0U)
323 checkSumVal = (checkSumVal & 0xFFFFU) + (checkSumVal >> 16U);
331 checkSumVal += (rlUInt32_t) (*((rlUInt8_t *)localGenHdr));
334 while ((checkSumVal >> 16U) != 0U)
336 checkSumVal = (checkSumVal & 0xFFFFU) + (checkSumVal >> 16U);
338 RL_LOGV_ARG1(
"Final checksum 0x%X\n", *checksum);
341 *(checksum) = (rlUInt16_t)~checkSumVal;
342 retVal = RL_RET_CODE_OK;
346 retVal = RL_RET_CODE_FATAL_ERROR;
349 RL_LOGV_ARG0(
"rlDriverCalChkSum ends...\n");
368 rlReturnVal_t retVal;
369 rlUInt16_t checkSum = 0U;
374 if (RL_RET_CODE_OK != rlDriverCalChkSum(&protHdr, ((rlUInt8_t)(RHCP_HEADER_LEN - 2U)),
378 retVal = RL_RET_CODE_RADAR_IF_ERROR;
383 if (protHdr.chksum != checkSum)
386 retVal = RL_RET_CODE_CHKSUM_FAILED;
387 RL_LOGE_ARG0(
"Checksum validation failed for header\n");
392 RL_LOGD_ARG0(
"Checksum validation is successful\n");
393 retVal= RL_RET_CODE_OK;
416 RL_LOGV_ARG0(
"rlDeviceIdentifyCmdDir starts...\n");
419 if ((RL_RF_RESP_ERROR_MSG < msgId) && (RL_RF_ASYNC_EVENT_MSG > msgId))
422 if (RL_PLATFORM_MSS == platform)
424 cmdDir = RL_API_DIR_MSS_TO_BSS;
427 else if (RL_PLATFORM_HOST == platform)
429 cmdDir = RL_API_DIR_HOST_TO_BSS;
434 cmdDir = RL_API_DIR_DSS_TO_BSS;
436 RL_LOGV_ARG1(
"cmdDir for radarSS = %d (1:host2Bss, 10:dss2Bss, 8:mss2bss)\n",\
440 else if ((RL_DEV_POWERUP_MSG <= msgId) && (RL_DEV_ASYNC_EVENT_MSG > msgId))
443 if (RL_PLATFORM_HOST == platform)
446 cmdDir = RL_API_DIR_HOST_TO_MSS;
451 cmdDir = RL_API_DIR_MSS_TO_DSS;
453 RL_LOGV_ARG1(
"cmdDir for MSS = %d (5:host2Mss, 12:dss2Mss)\n", cmdDir);
456 else if ((RL_DSP_RESERVED0_MSG <= msgId) && (RL_DSP_ASYNC_EVENT_MSG > msgId))
461 if (RL_PLATFORM_MSS == platform)
464 cmdDir = RL_API_DIR_MSS_TO_DSS;
470 cmdDir = RL_API_DIR_HOST_TO_DSS;
472 RL_LOGV_ARG1(
"cmdDir for DSS = %d (11:Mss2Dss, 3:hostDss)\n", cmdDir);
477 cmdDir = RL_API_DIR_INVALID;
478 RL_LOGE_ARG1(
"rlDeviceIdentifyCmdDir: Invalid cmd, platform: [%d]\n", platform);
480 RL_LOGV_ARG0(
"rlDeviceIdentifyCmdDir ends...\n");
501 rlUInt16_t nsbc, rlUInt8_t *payload,
502 rlUInt16_t payloadLen)
505 rlUInt16_t sbLen = 0U;
506 rlUInt16_t sbcId = 0U;
507 rlUInt16_t recSbsLen = 0U;
508 rlReturnVal_t retVal = RL_RET_CODE_OK;
509 rlUInt8_t *payldAddr = payload;
511 RL_LOGV_ARG0(
"rlDriverAsyncEventHandler starts...\n");
514 for (indx = 0U; indx < nsbc; indx++)
517 if ((payldAddr == RL_NULL_PTR) || (recSbsLen > payloadLen))
521 retVal = RL_RET_CODE_FATAL_ERROR;
525 rlGetSubBlockId(payldAddr, &sbcId);
528 rlGetSubBlockLen(payldAddr, &sbLen);
538 ((rlUInt16_t)(sbLen - RL_MIN_SBC_LEN)),\
539 (payldAddr + RL_SBC_PL_INDEX));
541 recSbsLen += (sbLen);
547 RL_LOGV_ARG0(
"rlDriverAsyncEventHandler ends...\n");
571 RL_LOGV_ARG0(
"rlDriverHostIrqHandler starts...\n");
574 if (pValue == RL_NULL_PTR)
577 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Input arg is NULL\n");
590 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Mask the Interrupt\n");
602 rlDrvData->isRespWriteWaited[deviceIndex]);
604 if (RL_TRUE == tempVar)
608 &rlDrvData->
cmdSem[deviceIndex]);
609 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Release command response \n");
616 (RL_P_OSI_SPAWN_ENTRY)rlDriverMsgReadSpawnCtx,
618 RL_LOGD_ARG0(
"rlDriverHostIrqHandler No response is expected \n");
621 RL_LOGV_ARG0(
"rlDriverHostIrqHandler ends...\n");
640 rlReturnVal_t retVal;
651 switch (rlDrvData->
funcParams[devIdx].rxMsgClass)
653 case RL_API_CLASS_ASYNC:
655 if (inVal == RL_RET_CODE_OK)
660 rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.hdr.nsbc,\
661 (rlUInt8_t *)&rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.payload[0],\
662 (rlUInt16_t)(rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.hdr.len - \
667 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
669 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
670 RL_MMWL_AE_MISMATCH_REPORT);
671 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
674 (void)memcpy(&errPayload[2], (rlUInt8_t*) &inVal,
sizeof(rlReturnVal_t));
681 (rlUInt8_t *)&errPayload[0],\
682 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
685 case RL_API_CLASS_NACK:
687 retVal = RL_RET_CODE_OK;
689 case RL_API_CLASS_RSP:
691 retVal = RL_RET_CODE_OK;
694 case RL_API_CLASS_CMD:
695 case RL_API_CLASS_BYPASS:
702 rlDrvData->
funcParams[devIdx].rxMsgClass, inVal);
708 retVal = RL_RET_CODE_OK;
711 case RL_API_CLASS_MAX:
713 retVal = RL_RET_CODE_OK;
717 retVal = RL_RET_CODE_PROTOCOL_ERROR;
718 RL_LOGE_ARG0(
"rlDriverProcRdMsg, Rl protocol error\n");
736 rlReturnVal_t rlDriverMsgReadSpawnCtx(
const void *pValue)
738 rlReturnVal_t retVal, msgRdRetVal;
739 rlUInt8_t deviceIndex;
740 rlUInt8_t lclRxIrqCnt, lclRxDoneCnt;
744 RL_LOGV_ARG0(
"rlDriverMsgReadSpawnCtx starts...\n");
747 if (pValue == RL_NULL_PTR)
751 RL_LOGE_ARG0(
"rlDriverMsgReadSpawnCtx Input arg is NULL\n");
756 deviceIndex = *(
const rlUInt8_t*)pValue;
766 (&rlDrvData->
devMutex[deviceIndex], (rlOsiTime_t)RL_OSI_WAIT_FOREVER))
768 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
770 rlReturnVal_t* ptrData;
773 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
774 RL_MMWL_AE_INTERNALERR_REPORT);
775 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
778 inVal = RL_RET_CODE_RADAR_OSIF_ERROR;
781 if (RL_NULL_PTR != ptrData)
787 (void)memcpy((
void*)&errPayload[2], (
void*)ptrData,
sizeof(rlReturnVal_t));
795 (rlUInt8_t *)&errPayload[0],\
796 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
802 lclRxIrqCnt = rlDrvData->
rxIrqCnt[deviceIndex];
803 lclRxDoneCnt = rlDrvData->
rxDoneCnt[deviceIndex];
806 if (lclRxIrqCnt == lclRxDoneCnt)
810 RL_LOGD_ARG0(
"rlDriverMsgReadSpawnCtx, RxIrqCnt is equal to RxDoneCnt\n");
811 retVal = RL_RET_CODE_OK;
825 (&rlDrvData->
devMutex[deviceIndex]);
828 RL_LOGV_ARG0(
"rlDriverMsgReadSpawnCtx ends...\n");
847 rlReturnVal_t retVal, retStatus;
850 RL_LOGV_ARG0(
"rlDriverMsgCmdReply starts...\n");
858 if (RL_RET_CODE_OK != (rlInt32_t)retStatus)
862 if (RL_API_CLASS_ASYNC == rlDrvData->
funcParams[devIndex].rxMsgClass)
864 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
866 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
867 RL_MMWL_AE_MISMATCH_REPORT);
868 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
870 (void)memcpy(&errPayload[2], (rlUInt8_t*)&retStatus,
sizeof(rlReturnVal_t));
877 (rlUInt8_t *)&errPayload[0],\
878 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
880 if (retStatus == RL_RET_CODE_CRC_FAILED)
884 retStatus = RL_RET_CODE_OK;
890 RL_LOGE_ARG0(
"Error in received data\n");
895 if (RL_API_CLASS_RSP == rlDrvData->
funcParams[devIndex].rxMsgClass)
902 if (rl_rxMsg[devIndex].hdr.opcode.b10MsgId != rl_txMsg[devIndex].hdr.
opcode.
b10MsgId)
905 retVal = RL_RET_CODE_MSGID_MISMATCHED;
906 RL_LOGE_ARG0(
"Msg id is mis-matched\n");
910 if (rl_rxMsg[devIndex].hdr.flags.b4SeqNum != rl_txMsg[devIndex].hdr.flags.
b4SeqNum)
912 retVal = RL_RET_CODE_RX_SEQ_NUM_NOT_MATCH;
913 RL_LOGV_ARG0(
"ACK sequence number is not matching with CMD sequence number\n");
918 retVal = RL_RET_CODE_OK;
926 (&(rlDrvData->
cmdSem[devIndex]), (rlOsiTime_t)RL_OSI_NO_WAIT);
928 else if (RL_API_CLASS_ASYNC == rlDrvData->
funcParams[devIndex].rxMsgClass)
937 rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.hdr.nsbc, \
938 (rlUInt8_t *)&rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.payload[0],
939 (rlUInt16_t)(rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.hdr.len - \
941 retVal = RL_RET_CODE_OK;
945 else if (RL_API_CLASS_NACK == rlDrvData->
funcParams[devIndex].rxMsgClass)
951 retVal = RL_RET_CODE_NACK_ERROR;
952 RL_LOGE_ARG0(
"CMD CRC check fails, device sends NACK\n");
957 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
958 RL_LOGE_ARG0(
"Invalid Class\n");
961 RL_LOGV_ARG0(
"rlDriverMsgCmdReply ends...\n");
981 rlReturnVal_t retVal;
984 RL_LOGV_ARG0(
"rlDriverMsgReadCmdCtx starts...\n");
986 if (RL_NULL_PTR == rlDrvData)
988 retVal = RL_RET_CODE_FATAL_ERROR;
996 retVal = RL_RET_CODE_OK;
1005 while ((RL_TRUE == rlDrvData->
isCmdRespWaited[devIndex]) && (RL_RET_CODE_OK == retVal))
1007 if (RL_PENDING_RX_MSG(rlDrvData, devIndex))
1011 rlDrvData->
funcParams[devIndex].rxMsgClass = RL_API_CLASS_MAX;
1024 &(rlDrvData->
cmdSem[devIndex]),
1030 RL_LOGE_ARG0(
"CmdSem should be signaled by IRQ but respTimeout\n");
1031 retVal += RL_RET_CODE_RESP_TIMEOUT;
1038 if (RL_PENDING_RX_MSG(rlDrvData, devIndex) && (retVal != RL_RET_CODE_FATAL_ERROR) \
1043 ((RL_P_OSI_SPAWN_ENTRY)rlDriverMsgReadSpawnCtx, \
1046 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
1050 RL_LOGV_ARG0(
"rlDriverMsgReadCmdCtx ends...\n");
1070 static rlReturnVal_t rlDriverOriginDirCheck(rlUInt8_t deviceRunId,
1073 rlReturnVal_t retVal;
1075 RL_LOGV_ARG0(
"rlDriverOriginDirCheck starts...\n");
1077 switch (deviceRunId)
1080 case RL_PLATFORM_HOST:
1081 if ((RL_API_DIR_BSS_TO_HOST == dataDir) ||
1082 (RL_API_DIR_MSS_TO_HOST == dataDir) ||
1083 (RL_API_DIR_DSS_TO_HOST == dataDir))
1087 retVal = RL_RET_CODE_OK;
1092 retVal = RL_RET_CODE_INVALID_INPUT;
1096 case RL_PLATFORM_MSS:
1097 if ((RL_API_DIR_BSS_TO_MSS == dataDir) ||
1098 (RL_API_DIR_DSS_TO_MSS == dataDir) ||
1099 (RL_API_DIR_HOST_TO_MSS == dataDir))
1103 retVal = RL_RET_CODE_OK;
1108 retVal = RL_RET_CODE_INVALID_INPUT;
1112 case RL_PLATFORM_DSS:
1114 if ((RL_API_DIR_BSS_TO_DSS == dataDir) ||
1115 (RL_API_DIR_MSS_TO_DSS == dataDir) ||
1116 (RL_API_DIR_HOST_TO_DSS == dataDir))
1120 retVal = RL_RET_CODE_OK;
1125 retVal = RL_RET_CODE_INVALID_INPUT;
1130 retVal = RL_RET_CODE_INVALID_INPUT;
1131 RL_LOGE_ARG2(
"Unknown platform %d, retVal = %d\n", \
1135 RL_LOGV_ARG0(
"rlDriverOriginDirCheck ends...\n");
1140 rlReturnVal_t rlDriverRdVerifyMsg(
rlReadBuf_t readBuf, rlUInt8_t devIndex)
1142 rlUInt16_t rxLengthRecv;
1143 rlReturnVal_t retVal, readRetVal;
1144 rlUInt16_t payloadLen, msgCrcLen, msgCrcType;
1145 rlUInt8_t isCrcPresent;
1148 rxLengthRecv = RL_RHCP_HDR_PL_LENGTH(&(readBuf.syncHeader.protHdr));
1151 if (rxLengthRecv >= (RL_MAX_SIZE_MSG - SYNC_PATTERN_LEN))
1153 retVal = RL_RET_CODE_PROTOCOL_ERROR;
1161 rl_driverData.
funcParams[devIndex].rxMsgClass =
1162 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1165 payloadLen = rxLengthRecv - (rlUInt16_t)RHCP_HEADER_LEN;
1167 if (RL_API_CLASS_ASYNC == rl_driverData.
funcParams[devIndex].rxMsgClass)
1173 rhcpMsg = &rl_driverData.
funcParams[devIndex].asyncEvt.evtMsg;
1178 rhcpMsg = &rl_rxMsg[devIndex];
1182 rhcpMsg->hdr = readBuf.syncHeader.protHdr;
1184 rhcpMsg->syncPattern = readBuf.syncHeader.syncPattern;
1187 if (rhcpMsg->hdr.flags.
b2Crc != 0U)
1190 isCrcPresent = RL_FALSE;
1196 isCrcPresent = RL_TRUE;
1198 msgCrcType = rhcpMsg->hdr.flags.
b2CrcLen;
1200 msgCrcLen = (2U << (msgCrcType & 0x3U));
1203 payloadLen = ((isCrcPresent == RL_TRUE) ? (payloadLen - msgCrcLen) : payloadLen);
1206 if (payloadLen > 0U)
1209 &rhcpMsg->payload[0U], payloadLen) != (rlInt32_t)payloadLen)
1212 readRetVal = RL_RET_CODE_RADAR_IF_ERROR;
1216 readRetVal = RL_RET_CODE_OK;
1221 readRetVal = RL_RET_CODE_OK;
1225 if ((isCrcPresent == RL_TRUE) && (readRetVal == RL_RET_CODE_OK))
1230 msgCrcLen) != (rlInt32_t)msgCrcLen)
1233 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1237 (void)memcpy(&rhcpMsg->payload[payloadLen], \
1238 &rl_driverData.
funcParams[devIndex].msgCRC[0U], msgCrcLen);
1241 if ((rl_driverData.
clientCtx.
crcType != (rlUInt8_t)RL_CRC_TYPE_NO_CRC) && \
1249 msgCrcLen), (rlUInt8_t)(msgCrcType), \
1254 retVal = RL_RET_CODE_OK;
1260 retVal = RL_RET_CODE_OK;
1282 rlReturnVal_t retVal, hdrRetVal;
1284 rlUInt16_t payloadLen;
1286 RL_LOGV_ARG0(
"rlDriverMsgRead starts...\n");
1288 if (RL_NULL_PTR == rlDrvData)
1291 retVal = RL_RET_CODE_FATAL_ERROR;
1295 rlReturnVal_t hdrType;
1300 RL_LOGV_ARG1(
"rlDriverRxHdrRead return val = %d\n", hdrType);
1304 if (SYNC_PATTERN_MATCHED == (rlInt32_t)(hdrType))
1312 if ((RL_RET_CODE_OK == hdrRetVal) && (RL_RET_CODE_OK == \
1314 (rlUInt8_t)readBuf.syncHeader.protHdr.opcode.b4Direction)))
1316 retVal = rlDriverRdVerifyMsg(readBuf, devIndex);
1318 else if (RL_RET_CODE_OK == hdrRetVal)
1320 rlDrvData->
funcParams[devIndex].rxMsgClass = RL_API_CLASS_BYPASS;
1325 rl_rxMsg[devIndex].syncPattern = readBuf.syncHeader.syncPattern;
1326 rl_rxMsg[devIndex].hdr = readBuf.syncHeader.protHdr;
1329 payloadLen = readBuf.syncHeader.protHdr.len - (rlUInt16_t)RHCP_HEADER_LEN;
1333 &rl_rxMsg[devIndex].payload[0], payloadLen) != (rlInt32_t)payloadLen)
1336 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1341 retVal = RL_RET_CODE_OK;
1347 else if ((RL_RET_CODE_CHKSUM_FAILED == hdrRetVal) && \
1350 rlUInt16_t dummyToFlushSpi[8U] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
1351 0xFFFF, 0xFFFF, 0xFFFF};
1357 for (readCnt = 1U; readCnt < (SYNC_PATTERN_LEN + RHCP_HEADER_LEN); readCnt++)
1360 (rlUInt8_t*)&dummyToFlushSpi[0U], (SYNC_PATTERN_LEN + \
1365 if (rl_txMsg[devIndex].hdr.flags.b2Crc == 0U)
1369 (rlUInt8_t*)&dummyToFlushSpi[0U], msgCrcLen);
1373 rl_driverData.
funcParams[devIndex].rxMsgClass = RL_API_CLASS_ASYNC;
1383 rl_driverData.
funcParams[devIndex].rxMsgClass =
1384 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1388 else if (CNYS_PATTERN_MATCHED == (rlInt32_t)(hdrType))
1399 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1406 if (hdrType == RL_RET_CODE_HOSTIRQ_TIMEOUT)
1408 rl_driverData.
funcParams[devIndex].rxMsgClass = RL_API_CLASS_ASYNC;
1413 rl_driverData.
funcParams[devIndex].rxMsgClass =
1414 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1420 (retVal != RL_RET_CODE_FATAL_ERROR))
1425 RL_LOGD_ARG0(
"rlDriverMsgRead Unmask Interrupt call\n");
1429 RL_LOGV_ARG0(
"rlDriverMsgRead ends...\n");
1449 rlComIfHdl_t comIfHdl)
1451 rlReturnVal_t retVal;
1453 RL_LOGV_ARG0(
"rlDriverMsgWrite starts...\n");
1456 if (((rlComIfHdl_t)RL_NULL != comIfHdl) && (rlDrvData != RL_NULL_PTR))
1458 rlUInt16_t checkSum = 0U, msgCrcLen;
1459 rlUInt16_t payloadLen;
1464 (void)rlDriverCalChkSum(&rl_txMsg[devIndex].hdr, ((rlUInt8_t)(RHCP_HEADER_LEN - 2U)),
1466 rl_txMsg[devIndex].hdr.chksum = checkSum;
1469 payloadLen = rl_txMsg[devIndex].hdr.len - (rlUInt16_t)RHCP_HEADER_LEN;
1470 RL_LOGV_ARG1(
"API Dir = %d \n", rl_txMsg[devIndex].hdr.opcode.b4Direction);
1473 if ((RL_API_DIR_DSS_TO_HOST == rl_txMsg[devIndex].hdr.opcode.b4Direction) || \
1478 rl_txMsg[devIndex].syncPattern.sync1 = D2H_SYNC_PATTERN_1;
1479 rl_txMsg[devIndex].syncPattern.sync2 = D2H_SYNC_PATTERN_2;
1484 rl_txMsg[devIndex].syncPattern.sync1 = H2D_SYNC_PATTERN_1;
1485 rl_txMsg[devIndex].syncPattern.sync2 = H2D_SYNC_PATTERN_2;
1489 if (rl_txMsg[devIndex].hdr.flags.b2Crc == RL_HDR_FLAG_CRC)
1498 (rl_txMsg[devIndex].hdr.len - msgCrcLen),
1502 (void)memcpy((rlUInt8_t*)(&rl_txMsg[devIndex].payload[payloadLen - msgCrcLen]),
1503 (rlUInt8_t*)&(rlDrvData->
funcParams[devIndex].msgCRC[0]), msgCrcLen);
1505 tempLen = ((rlUInt16_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN) + payloadLen);
1509 if (RL_IF_WRITE(comIfHdl, ((rlUInt8_t *)&rl_txMsg[devIndex]), \
1510 tempLen) != (rlInt32_t)tempLen)
1513 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1518 retVal = RL_RET_CODE_OK;
1524 retVal = RL_RET_CODE_FATAL_ERROR;
1526 RL_LOGV_ARG0(
"rlDriverMsgWrite ends...\n");
1546 static rlUInt8_t rlDriverReceiveSync(rlComIfHdl_t comIfHdl, rlUInt8_t syncBuf[],
1547 rlInt32_t *syncType)
1549 rlUInt8_t count = 0;
1552 rlReturnVal_t errVal;
1554 RL_LOGV_ARG0(
"rlDriverReceiveSync starts...\n");
1557 if (syncType != (rlInt32_t*)RL_NULL)
1560 if (RL_IF_READ(comIfHdl, &syncBuf[0U], (rlUInt16_t)SYNC_PATTERN_LEN) != \
1561 (rlInt32_t)SYNC_PATTERN_LEN)
1564 errVal = RL_RET_CODE_RADAR_IF_ERROR;
1569 (void)memcpy(&recSyncPattern, &syncBuf[0U], SYNC_PATTERN_LEN);
1570 errVal = RL_RET_CODE_OK;
1572 retVal = PATTERN_NOT_MATCHED;
1575 while (((retVal) == (rlInt32_t)PATTERN_NOT_MATCHED) && (errVal == RL_RET_CODE_OK))
1578 if (((recSyncPattern.sync1 == H2D_SYNC_PATTERN_1) &&
1579 (recSyncPattern.sync2 == H2D_SYNC_PATTERN_2) ) || \
1580 ((recSyncPattern.sync1 == D2H_SYNC_PATTERN_1) &&
1581 (recSyncPattern.sync2 == D2H_SYNC_PATTERN_2)))
1585 retVal = SYNC_PATTERN_MATCHED;
1591 if ((recSyncPattern.sync1 == H2D_CNYS_PATTERN_1) &&
1592 (recSyncPattern.sync2 == H2D_CNYS_PATTERN_2))
1596 retVal = CNYS_PATTERN_MATCHED;
1599 else if (count >= (rlUInt16_t)RL_SYNC_SCAN_THRESHOLD)
1604 if (RL_IF_READ(comIfHdl, &syncBuf[SYNC_PATTERN_LEN], (rlUInt16_t)crcLen) != \
1608 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1613 errVal += RL_RET_CODE_PROTOCOL_ERROR;
1619 if (0 == (count % SYNC_PATTERN_LEN))
1622 if (RL_IF_READ(comIfHdl, &syncBuf[SYNC_PATTERN_LEN],\
1623 (rlUInt16_t)SYNC_PATTERN_LEN) != \
1624 (rlInt32_t)SYNC_PATTERN_LEN)
1627 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1634 (void)memcpy(&recSyncPattern, &syncBuf[0U], SYNC_PATTERN_LEN);
1641 if (errVal == RL_RET_CODE_OK)
1643 *(syncType) = retVal;
1647 *(syncType) = errVal;
1650 count %= SYNC_PATTERN_LEN;
1651 RL_LOGV_ARG1(
"rlDriverReceiveSync, count = %d\n", count);
1652 RL_LOGV_ARG0(
"rlDriverReceiveSync ends...\n");
1678 rlUInt8_t syncBuf[SYNC_PATTERN_LEN * 2] = {0U};
1684 rlUInt16_t cnysBuf[8U] = {H2D_CNYS_PATTERN_1, H2D_CNYS_PATTERN_2,
1685 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU};
1686 rlInt32_t syncType = PATTERN_NOT_MATCHED;
1690 RL_LOGV_ARG0(
"rlDriverRxHdrRead starts...\n");
1693 if ((rlComIfHdl_t)RL_NULL == comIfHdl)
1695 errVal = RL_RET_CODE_FATAL_ERROR;
1704 if (RL_IF_WRITE(comIfHdl,
1705 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN)) !=\
1706 (rlInt32_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN))
1709 errVal = RL_RET_CODE_RADAR_IF_ERROR;
1713 errVal = RL_RET_CODE_OK;
1716 RL_LOGV_ARG2(
"Platform = %d, delay = %d \n",\
1723 0U) != RL_RET_CODE_OK) && (errVal == RL_RET_CODE_OK))
1726 if (RL_IF_WRITE(comIfHdl,
1727 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN)) !=\
1728 (rlInt32_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN))
1731 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1737 errVal += RL_RET_CODE_HOSTIRQ_TIMEOUT;
1753 errVal = RL_RET_CODE_OK;
1756 if (errVal == RL_RET_CODE_OK)
1761 syncCnt = rlDriverReceiveSync(comIfHdl, &syncBuf[0U], &syncType);
1762 RL_LOGV_ARG1(
"syncType = %d \n", syncType);
1764 if ((CNYS_PATTERN_MATCHED == syncType) || (SYNC_PATTERN_MATCHED == syncType))
1767 rlUInt8_t* payloadBuf;
1769 payloadBuf = &syncBuf[0U];
1770 if (RL_NULL_PTR != payloadBuf)
1775 (void)memcpy(&hdrBuf[0], payloadBuf, (SYNC_PATTERN_LEN + syncCnt));
1777 tempLen = RHCP_HEADER_LEN - (0x00FFU & syncCnt);
1779 if (RL_IF_READ(comIfHdl, (&hdrBuf[(SYNC_PATTERN_LEN + syncCnt)]), \
1780 tempLen) != (rlInt32_t)tempLen)
1782 syncType += RL_RET_CODE_RADAR_IF_ERROR;
1788 RL_LOGD_ARG0(
"do nothing ");
1798 RL_LOGV_ARG0(
"rlDriverRxHdrRead ends...\n");
1815 rlReturnVal_t retVal;
1816 rlInt32_t funcRetVal = RL_RET_CODE_OK;
1818 rlInt8_t CmdSemStr[9] =
"CmdSem_";
1819 rlInt8_t devMutexStr[11] =
"devMutex_";
1821 for (index = 0U; index < RL_CASCADE_NUM_DEVICES; index++)
1826 CmdSemStr[7] = (rlInt8_t)(index+48U);
1829 CmdSemStr[8] = (rlInt8_t)
'\0';
1831 &rl_driverData.
cmdSem[index], CmdSemStr);
1836 devMutexStr[9] = (rlInt8_t)(index+48U);
1839 devMutexStr[10] = (rlInt8_t)
'\0';
1841 &rl_driverData.
devMutex[index], devMutexStr);
1845 if (funcRetVal != RL_RET_CODE_OK)
1848 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
1852 retVal = RL_RET_CODE_OK;
1858 static rlReturnVal_t rlDriverOsiCbCheck(
rlClientCbs_t clientCb)
1860 rlReturnVal_t retVal;
1863 if ((RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexCreate) ||
1864 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexLock ) ||
1865 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexUnLock) ||
1866 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexDelete))
1868 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1871 else if ((RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemCreate) ||
1872 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemWait ) ||
1873 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemSignal) ||
1874 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemDelete))
1876 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1884 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1889 retVal = RL_RET_CODE_OK;
1904 static rlReturnVal_t rlDriverClientCbCheck(
rlClientCbs_t clientCb)
1906 rlReturnVal_t retVal;
1908 if (RL_RET_CODE_OK != rlDriverOsiCbCheck(clientCb))
1910 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1918 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1921 else if (((clientCb.
platform == RL_PLATFORM_HOST) &&
1923 (RL_NULL_PTR == clientCb.
timerCb.rlDelay)))) ||
1924 (RL_NULL_PTR == clientCb.
osiCb.
queue.rlOsiSpawn))
1926 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1930 (RL_NULL_PTR == clientCb.
devCtrlCb.rlRegisterInterruptHandler) ||
1931 ((RL_CRC_TYPE_NO_CRC != clientCb.
crcType) &&
1932 (RL_NULL_PTR == clientCb.
crcCb.rlComputeCRC)))
1934 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1938 retVal = RL_RET_CODE_OK;
1957 rlReturnVal_t rlDriverInit(rlUInt8_t deviceMap,
rlClientCbs_t clientCb)
1959 rlReturnVal_t retVal, cbCheck;
1960 rlUInt8_t index = 0U;
1963 cbCheck = rlDriverClientCbCheck(clientCb);
1965 if (RL_RET_CODE_OK != cbCheck)
1970 else if (deviceMap <= ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U))
1973 for (; index < RL_DEVICE_CONNECTED_MAX; index++)
1978 rl_driverData.
rxIrqCnt[index] = 0U;
1981 for (index = 0U; index < RL_CASCADE_NUM_DEVICES; index++)
1983 rl_driverData.
txMsgPtr[index] = &rl_txMsg[index];
1984 rl_driverData.
rxMsgPtr[index] = &rl_rxMsg[index];
1992 rl_driverData.
retryCount = RL_API_CMD_RETRY_COUNT;
1997 #if !(RL_DISABLE_LOGGING) 1998 if (RL_RET_CODE_OK == retVal)
2001 retVal += rlLogInit();
2002 RL_LOGV_ARG0(
"Logging is enabled \n");
2010 if (((deviceMap & (1U << index)) != 0U) && (retVal == RL_RET_CODE_OK))
2023 retVal += RL_RET_CODE_RADAR_IF_ERROR;
2030 (
void*)RL_NULL) != RL_RET_CODE_OK)
2032 retVal +=RL_RET_CODE_RADAR_IF_ERROR;
2036 deviceMap &= ~(1U << index);
2039 if (retVal != RL_RET_CODE_OK)
2048 while ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));
2052 retVal = RL_RET_CODE_INVALID_INPUT;
2053 RL_LOGE_ARG0(
"Invaid input argument\n");
2057 if (retVal == RL_RET_CODE_OK)
2060 RL_LOGD_ARG0(
"Driver init flag is set\n");
2064 RL_LOGE_ARG0(
"rlDriverInit, Init failed\n");
2083 rlReturnVal_t retVal;
2084 rlUInt8_t index = 0U;
2086 RL_LOGV_ARG0(
"rlDriverAddDevice starts\n");
2089 (deviceMap <= ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U)))
2097 if ((deviceMap & (1U << index)) != 0U)
2105 rl_driverData.clientCtx.comIfCb.rlComIfOpen(index, 0U);
2112 (
void*)RL_NULL) != RL_RET_CODE_OK) ||
2116 retVal = RL_RET_CODE_RADAR_IF_ERROR;
2120 retVal = RL_RET_CODE_OK;
2125 retVal =RL_RET_CODE_RADAR_IF_ERROR;
2127 deviceMap &= ~(1U << index);
2131 retVal = RL_RET_CODE_OK;
2135 if (RL_RET_CODE_OK != retVal)
2142 while ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));
2146 if (deviceMap > ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U))
2148 retVal = RL_RET_CODE_INVALID_INPUT;
2149 RL_LOGE_ARG0(
"Invalid input argument\n");
2153 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2154 RL_LOGE_ARG0(
"rlDriverAddDevice, Invalid state \n");
2157 RL_LOGV_ARG0(
"rlDriverAddDevice completes\n");
2177 rlReturnVal_t retVal = RL_RET_CODE_OK;
2179 RL_LOGV_ARG0(
"rlDriverRemoveDevices starts...\n");
2184 for (index = 0U; ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));\
2187 if ((deviceMap & (1U << index)) != 0U)
2199 index, RL_NULL, RL_NULL);
2201 deviceMap &= ~(1U << index);
2204 RL_LOGV_ARG0(
"rlDriverRemoveDevices completes\n");
2221 rlUInt8_t index, devCnt;
2222 rlUInt8_t deviceMap = rl_driverData.
deviceMap;
2223 rlReturnVal_t retVal = RL_RET_CODE_OK;
2225 RL_LOGV_ARG0(
"rlDriverDeInit starts...\n");
2227 for (index = 0U; ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));\
2230 if ((deviceMap & (1U << index)) != 0U)
2242 index, RL_NULL, RL_NULL);
2244 deviceMap &= ~(1U << index);
2248 for (devCnt = 0U; devCnt < RL_CASCADE_NUM_DEVICES; devCnt++)
2255 rl_driverData.
devMutex[devCnt] = RL_NULL_PTR;
2257 RL_LOGD_ARG0(
"Destroy Per CMD Mutex\n");
2260 if (rl_driverData.
cmdSem[devCnt] != RL_NULL_PTR)
2263 &rl_driverData.
cmdSem[devCnt]);
2264 rl_driverData.
cmdSem[devCnt] = RL_NULL_PTR;
2265 RL_LOGD_ARG0(
"Destroy Command Semaphore\n");
2271 RL_LOGV_ARG0(
"rlDriverDeInit ends...\n");
2289 return (&rl_driverData);
2304 RL_LOGV_ARG0(
"rlDriverGetPlatformId is called \n");
2322 RL_LOGV_ARG0(
"rlDriverGetArDeviceType is called \n");
2341 rlUInt8_t storedDevMap;
2342 rlReturnVal_t retVal;
2344 RL_LOGV_ARG0(
"rlDriverIsDeviceMapValid starts \n");
2349 if ((storedDevMap & deviceMap) != 0U)
2358 RL_LOGE_ARG0(
"Device map is In-valid \n");
2360 RL_LOGV_ARG0(
"rlDriverIsDeviceMapValid ends \n");
2385 rlUInt16_t rspChunks;
2387 rlReturnVal_t retVal, retVal1;
2389 rlUInt8_t payloadLen = 0U;
2391 RL_LOGV_ARG0(
"rlDriverWaitForResponse starts... \n");
2397 if (RL_RET_CODE_OK == retVal1)
2400 rspChunks = rl_rxMsg[devIndex].hdr.remChunks;
2403 if (outMsg->opcode.
nsbc >= rl_rxMsg[devIndex].hdr.nsbc)
2405 outMsg->opcode.
nsbc = rl_rxMsg[devIndex].hdr.nsbc;
2407 for (indx = 0U; indx < (outMsg->opcode.
nsbc); indx++)
2412 (void)rlGetSubBlock(rl_rxMsg[devIndex].payload + payloadLen,
2413 &(outMsg->subblocks[indx].sbid),
2414 &(outMsg->subblocks[indx].len),
2415 outMsg->subblocks[indx].pSblkData);
2416 payloadLen += (rlUInt8_t)(outMsg->subblocks[indx].len);
2422 else if (RL_RET_CODE_MSGID_MISMATCHED == retVal1)
2428 rlErrorResp_t errMsgSbData = {(rlSysNRespType_t)0U, (rlUInt16_t)0U};
2432 errorSB.pSblkData = (rlUInt8_t* )&errMsgSbData;
2437 (void)rlGetSubBlock(rl_rxMsg[devIndex].payload + payloadLen,
2438 &(errorSB.sbid), &(errorSB.len),
2442 retVal = (rlReturnVal_t)(errMsgSbData.
errorType);
2445 RL_LOGE_ARG0(
"msg id mis-match, command failure\n");
2453 RL_LOGE_ARG0(
"Timeout in receiving response\n");
2456 while (rspChunks > 0U);
2458 RL_LOGV_ARG0(
"rlDriverWaitForResponse ends... \n");
2463 static rlReturnVal_t rlDriverCmdWriter(rlUInt8_t devIndex,
rlDriverMsg_t* outMsg)
2465 rlReturnVal_t retVal;
2466 rlUInt8_t retryCount = 0U;
2468 rlUInt8_t isPayloadValid = RL_FALSE, isNackRetry = RL_FALSE;
2472 if ((retryCount != 0U) && (isNackRetry == RL_FALSE))
2494 if (RL_RET_CODE_OK == retVal)
2501 RL_LOGD_ARG0(
"rlDriverCmdWriter, wait for respond\n");
2505 if ((RL_RET_CODE_OK == retVal) || \
2506 ((RL_RET_CODE_CRC_FAILED != retVal) && \
2507 (RL_RET_CODE_RESP_TIMEOUT != retVal)))
2517 if (RL_RET_CODE_NACK_ERROR == retVal)
2520 isNackRetry = RL_TRUE;
2533 isPayloadValid = RL_TRUE;
2535 isNackRetry = RL_FALSE;
2541 isNackRetry = RL_FALSE;
2554 RL_LOGE_ARG0(
"rlDriverCmdWriter, Error in cmd msg write\n");
2558 while ((retryCount < (rl_driverData.
retryCount + 1U)) && (isPayloadValid == RL_FALSE));
2579 rlReturnVal_t retVal;
2582 if ((rlDrvData == RL_NULL))
2584 retVal = RL_RET_CODE_FATAL_ERROR;
2588 retVal = RL_RET_CODE_OK;
2603 retVal += rlDriverCmdWriter(devIndex, outMsg);
2624 static void rlDriverAppendDummyByte(rlUInt8_t devIndex)
2626 rlUInt8_t protAlignSize;
2627 rlUInt16_t msgCrcLen;
2634 protAlignSize = (rl_driverData.
clientCtx.
crcType < RL_CRC_TYPE_64BIT_ISO) ? \
2635 RL_PAYLOAD_MSG_4BYTE_MULT : RL_PAYLOAD_MSG_8BYTE_MULT;
2638 if (rl_driverData.
txMsgPtr[devIndex] != RL_NULL_PTR)
2641 if ((rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize) != 0U)
2653 (void)rlAppendDummy((rlUInt8_t*)(((rlUInt8_t*)rl_driverData.
txMsgPtr[devIndex]) + \
2654 rl_driverData.txMsgPtr[devIndex]->hdr.len + SYNC_PATTERN_LEN), \
2655 (rlUInt8_t)(protAlignSize - \
2656 (rlUInt8_t)(rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize)));
2657 rl_driverData.
txMsgPtr[devIndex]->hdr.len += (rlUInt16_t)(protAlignSize - \
2658 (rlUInt16_t)(rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize));
2661 rl_driverData.
txMsgPtr[devIndex]->hdr.len += msgCrcLen;
2687 rlReturnVal_t retVal = RL_RET_CODE_OK;
2688 rlUInt8_t devIndex = 0U;
2690 rlUInt16_t payloadLen;
2692 RL_LOGV_ARG0(
"rlDriverCmdInvoke starts... \n");
2699 while ((deviceMap != 0U) && (RL_RET_CODE_OK == retVal))
2701 if ((deviceMap & (1U << devIndex)) != 0U)
2705 (&(rl_driverData.
devMutex[devIndex]), (rlOsiTime_t)RL_OSI_WAIT_FOREVER))
2709 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
2713 rlReturnVal_t retVal1 = RL_RET_CODE_OK;
2724 (inMsg.opcode.
msgId & 0x3FFU));
2725 rl_txMsg[devIndex].hdr.remChunks = inMsg.remChunks;
2726 rl_txMsg[devIndex].hdr.nsbc = inMsg.opcode.
nsbc;
2727 rl_txMsg[devIndex].hdr.flags.
b2AckFlag = 0U;
2728 rl_txMsg[devIndex].hdr.flags.
b2Crc = 0U;
2729 rl_txMsg[devIndex].hdr.flags.
b2CrcLen = 0U;
2731 rl_txMsg[devIndex].hdr.flags.
b4SeqNum = 0U;
2732 rl_txMsg[devIndex].hdr.flags.
b4Version = 0U;
2735 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2738 retVal1 += rlAppendSubBlock(&rl_txMsg[devIndex].payload[payloadLen],
2739 inMsg.subblocks[indx].sbid,
2740 inMsg.subblocks[indx].len,
2741 inMsg.subblocks[indx].pSblkData);
2744 payloadLen += inMsg.subblocks[indx].len + \
2745 (rlUInt16_t)(RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE);
2746 if (RL_RET_CODE_OK != retVal1)
2753 if (indx == inMsg.opcode.
nsbc)
2755 rl_txMsg[devIndex].hdr.len = RHCP_HEADER_LEN + payloadLen;
2761 rl_txMsg[devIndex].hdr.flags.
b2AckFlag = RL_HDR_FLAG_NO_ACK;
2768 rl_txMsg[devIndex].hdr.flags.
b2Crc = RL_HDR_FLAG_NO_CRC;
2772 if (rl_txMsg[devIndex].hdr.flags.b2Crc == RL_HDR_FLAG_CRC)
2774 rlDriverAppendDummyByte(devIndex);
2780 &(rl_driverData.
devMutex[devIndex]));
2787 deviceMap &= ~(1U << devIndex);
2794 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2795 RL_LOGE_ARG0(
"rlDriverCmdInvoke, Invalid input \n");
2798 RL_LOGV_ARG0(
"rlDriverCmdInvoke ends... \n");
2814 rlReturnVal_t retVal;
2816 RL_LOGV_ARG0(
"rlDriverConfigureCrc starts... \n");
2822 RL_LOGD_ARG0(
"rlDriverConfigureCrc is success\n");
2823 retVal = RL_RET_CODE_OK;
2828 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2830 RL_LOGV_ARG0(
"rlDriverConfigureCrc ends... \n");
2848 rlReturnVal_t retVal;
2850 RL_LOGV_ARG0(
"rlDriverConfigureAckTimeout starts... \n");
2856 RL_LOGD_ARG0(
"rlDriverConfigureAckTimeout is success\n");
2857 retVal = RL_RET_CODE_OK;
2862 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2864 RL_LOGV_ARG0(
"rlDriverConfigureAckTimeout ends... \n");
2881 rlPrintFptr rlGetLogFptr(rlUInt8_t dbgLevel)
2883 rlPrintFptr retFuncPtr;
2887 retFuncPtr = rl_driverData.
logObj.rlPrintAr[dbgLevel - (rlUInt8_t)1U];
2892 retFuncPtr = RL_NULL_PTR;
2909 rlReturnVal_t rlLogInit(
void)
2911 rlReturnVal_t retVal;
2914 rlUInt8_t level, idx;
2921 if (fPtr != RL_NULL_PTR)
2925 case RL_DBG_LEVEL_VERBOSE :
2926 case RL_DBG_LEVEL_DEBUG :
2927 case RL_DBG_LEVEL_INFO :
2928 case RL_DBG_LEVEL_WARNING :
2929 case RL_DBG_LEVEL_ERROR :
2930 for (idx = level; idx > RL_DBG_LEVEL_NONE; idx--)
2932 rlDrvData->
logObj.rlPrintAr[idx - 1U] = fPtr;
2935 case RL_DBG_LEVEL_NONE :
2937 (void)fPtr(
"INFO: MMWAVELINK Logging is disabled\n");
2944 (void)fPtr(
"INFO: Invalid MMWAVELINK Logging, hence disbled\n");
2953 retVal = RL_RET_CODE_OK;
2959 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
2984 inMsg->opcode.
nsbc = 1U;
2985 inMsg->opcode.
msgType = RL_API_CLASS_CMD;
2986 inMsg->opcode.
msgId = msgId;
2987 inMsg->remChunks = 0U;
2990 inMsg->opcode.
dir = cmdDir;
2991 inMsg->subblocks = payloadPtr;
2996 RL_LOGV_ARG0(
"rlDriverConstructInMsg construct InMsg failed!!!\n");
3019 outMsg->opcode.
nsbc = numSblk;
3021 outMsg->subblocks = payloadPtr;
3026 RL_LOGV_ARG0(
"rlDriverConstructOutMsg construct OutMsg failed!!!\n");
3044 rlUInt8_t* data, rlUInt16_t inLen)
3047 if (payloadPtr != NULL)
3050 payloadPtr->sbid = (rlUInt16_t)RL_GET_UNIQUE_SBID(msgId, sbcID);
3053 payloadPtr->len = inLen;
3055 payloadPtr->pSblkData = data;
3059 RL_LOGV_ARG0(
"rlDriverFillPayload data fill failed!!!\n");
3077 rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
3080 rlReturnVal_t retVal;
3133 rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
3136 rlReturnVal_t retVal;
3176 rlReturnVal_t retVal;
3178 RL_LOGV_ARG0(
"rlDriverSetRetryCount starts... \n");
3182 if (retryCnt <= RL_API_CMD_RETRY_COUNT)
3186 RL_LOGD_ARG0(
"rlDriverSetRetryCount is success\n");
3187 retVal = RL_RET_CODE_OK;
3194 retVal = RL_RET_CODE_INVALID_INPUT;
3200 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
3202 RL_LOGV_ARG0(
"rlDriverSetRetryCount ends... \n");
rlReturnVal_t rlDriverMsgWrite(rlDriverData_t *rlDrvData, rlUInt8_t devIndex, rlComIfHdl_t comIfHdl)
Write command header and payload data over communication channel.
rlReturnVal_t rlDriverMsgReadCmdCtx(rlUInt8_t devIndex)
Wait and handle command response.
rlUInt16_t b2MsgType
Msg Type.
rlUInt16_t b2Crc
00 - CRC present, 11 - CRC not Present
rlOsiCbs_t osiCb
Operating System Callback.
mmWaveLink client callback structure
volatile rlUInt8_t isCmdRespWaited[RL_DEVICE_CONNECTED_MAX]
Driver Command Wait Flag.
rlUInt8_t dir
Message Direction.
rlRhcpMsg_t * txMsgPtr[RL_CASCADE_NUM_DEVICES]
Tx message buffer pointer.
rlInt32_t(* rlDeviceEnable)(rlUInt8_t deviceIndex)
Bring mmWave radar device out of Reset.
rlReturnVal_t rlDriverMsgCmdReply(rlDriverData_t *rlDrvData, rlUInt8_t devIndex)
Wait and handle command response.
rlUInt8_t rlDeviceIdentifyCmdDir(rlUInt16_t msgId, rlUInt8_t platform)
Get the direction of command packet based on MsgID and platform.
rlReturnVal_t rlDriverConfigureCrc(rlCrcType_t crcType)
Configures the CRC Type in mmwavelink Driver.
rlUInt8_t platform
0x0: mmWaveLink runs on Ext Host, 0x1: mmWaveLink runs on MSS, 0x2: mmWaveLink runs on DSS
volatile rlUInt8_t rxIrqCnt[RL_DEVICE_CONNECTED_MAX]
Driver Host Interrupt count.
rlUInt8_t msgType
Message Class.
void rlDriverConstructOutMsg(rlUInt16_t numSblk, rlDriverMsg_t *outMsg, rlPayloadSb_t *payloadPtr)
: Construct command packet based on given message-ID and payload
rlUInt8_t rlDevIndex[RL_DEVICE_CONNECTED_MAX]
stores device Index
rlUInt32_t ackTimeout
ACK wait timeout in Milliseconds, 0 - No ACK Configuration of the timeout should consider interrupt l...
rlUInt16_t msgId
Message Id.
rlUInt16_t cmdSeqNum[RL_DEVICE_CONNECTED_MAX]
Driver command sequnce number.
rlOsiMsgQCbs_t queue
OS message queue/Spawn callback functions.
rlUInt8_t rlDriverGetPlatformId(void)
Returns RL Platform ID (i.e. where mmWaveLink is executing)
volatile rlUInt8_t rxDoneCnt[RL_DEVICE_CONNECTED_MAX]
Driver serviced Host Interrupt count.
rlUInt16_t b2CrcLen
Length of CRC appended to the message 00 16-bit CRC 01 32-bit CRC 10 64-bit CRC 11 Reserved.
rlLogCtx_t logObj
As per debug level callback functions will be assinged.
rlUInt8_t isRespWriteWaited[RL_DEVICE_CONNECTED_MAX]
if writing a data waits for Host IRQ
rlReturnVal_t rlDriverCalCRC(rlUInt8_t *data, rlUInt16_t dataLen, rlUInt8_t crcType, rlUInt8_t crc[RL_CRC_LEN_MAX])
Calculates 16bit/32bit/64bit CRC.
rlComIfCbs_t comIfCb
Comunication Interface Callback.
rlOsiSemCbs_t sem
Semaphore callback functions.
rlRhcpMsg_t * rxMsgPtr[RL_CASCADE_NUM_DEVICES]
Rx message buffer pointer.
rlReturnVal_t rlDriverValidateHdr(rlProtHeader_t protHdr)
Validates the header by comparing Checksum.
rlOsiMutexCbs_t mutex
Mutex callback functions.
rlDbgCb_t dbgCb
Debug Callback, required to receive Debug information.
rlUInt16_t b4SeqNum
Sequence Number.
rlUInt8_t arDevType
xWR1243/AWR2243 + HOST = 0x0, xWR1443 MSS = 0x1, xWR1642 MSS/DSS = 0x2, xWR1843 MSS/DSS = 0x3,...
rlUInt16_t b2AckFlag
00- ACK requested, 11 - No ACK Requested
rlInt32_t(* rlComIfRead)(rlComIfHdl_t fd, rlUInt8_t *pBuff, rlUInt16_t len)
Read Data from Communication interface.
rlOsiSemHdl_t cmdSem[RL_CASCADE_NUM_DEVICES]
Driver Command Wait Semaphore.
void rlDriverConstructInMsg(rlUInt16_t msgId, rlDriverMsg_t *inMsg, rlPayloadSb_t *payloadPtr)
: Construct command packet (inMsg) based on given message-ID and payload
mmwave radar Driver Global Structure
rlReturnVal_t rlDriverCmdSendRetry(rlUInt8_t devIndex, rlDriverMsg_t *outMsg)
: Send command and wait for response
rlComIfHdl_t comIfHdl[RL_DEVICE_CONNECTED_MAX]
Communication Interface Handles.
rlUInt8_t isDriverInitialized
Driver Status.
rlReturnVal_t rlDriverMsgRead(rlDriverData_t *rlDrvData, rlUInt8_t devIndex)
Receive and validate protocol header and payload.
rlUInt16_t nsbc
Number of Sub Blocks in Payload.
rlInt32_t(* rlComIfClose)(rlComIfHdl_t fd)
Close the Communication interface.
rlUInt16_t b4Direction
Direction.
rlEventCbs_t eventCb
Event Callback, required to receive notification.
rlComIfHdl_t(* rlComIfOpen)(rlUInt8_t deviceIndex, rlUInt32_t flags)
Open Communication interface.
rlReturnVal_t rlDriverExecuteGetApi(rlUInt8_t deviceMap, rlUInt16_t msgId, rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
: Construct get message and invoke command.
rlUInt8_t dbgLevel
User needs to set debug level such as error, warning, debug, verbose.
rlReturnVal_t rlDriverSetRetryCount(rlUInt8_t retryCnt)
: Set the retry count for re-sending command
rlReturnVal_t rlDriverRxHdrRead(rlUInt8_t hdrBuf[RHCP_HEADER_LEN], rlComIfHdl_t comIfHdl)
Read SYNC and Header from communication channel.
rlUInt8_t rlDriverGetArDeviceType(void)
Returns AR device type which mmWavelink is communicating.
mmwave radar Driver Protocol header read buffer
rlOsiMutexHdl_t devMutex[RL_CASCADE_NUM_DEVICES]
Driver Global Lock Mutex.
rlReturnVal_t rlDriverDeInit(void)
De Initializes the mmwave radar Driver.
void(* rlDeviceMaskHostIrq)(rlComIfHdl_t fd)
Masks Host Interrupt.
rlDriverData_t * rlDriverGetHandle(void)
Returns mmwave radar Driver Global Structure.
void rlDriverHostIrqHandler(rlUInt8_t deviceIndex, void *pValue)
Interrupt Service Routine to handle host interrupt from mmwave radar device.
rlReturnVal_t rlDriverAsyncEventHandler(rlUInt8_t devIndex, rlUInt16_t nsbc, rlUInt8_t *payload, rlUInt16_t payloadLen)
Handles asynchronous response/error from mmwave radar device.
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)
mmwave radar Driver Payload
rlTimerCbs_t timerCb
Timer Callback, required when ACK is enabled.
rlCrcCbs_t crcCb
CRC Callback, required when CRC is enabled.
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.
rlUInt16_t b2RetryFlag
00- No Retry, 11 - Retry
rlReturnVal_t rlDriverConfigureAckTimeout(rlUInt32_t ackTimeout)
Configures the Acknowledgement timeout in mmwavelink Driver.
void(* rlAsyncEvent)(rlUInt8_t devIndex, rlUInt16_t subId, rlUInt16_t subLen, rlUInt8_t *payload)
Reports Asynchronous events from mmwave radar device such as device status, exceptions etc.
rlReturnVal_t rlDriverOsiInit(void)
Initializes the OSI layer abstraction for mmwavelink.
rlUInt16_t b10MsgId
Message ID.
rlReturnVal_t rlDriverVerifyCRC(rlUInt8_t *data, rlUInt16_t dataLen, rlUInt8_t crcType, rlUInt8_t crc[RL_CRC_LEN_MAX])
Compares received CRC with Calculated CRC.
rlReturnVal_t rlDriverRemoveDevices(rlUInt8_t deviceMap)
Disconnects the mmwave radar devices.
rlFunctionParams_t funcParams[RL_CASCADE_NUM_DEVICES]
Current API parameters.
rlInt32_t(* rlComIfWrite)(rlComIfHdl_t fd, rlUInt8_t *pBuff, rlUInt16_t len)
Write Data over Communication interface.
rlInt32_t(* rlDeviceDisable)(rlUInt8_t deviceIndex)
Power off mmWave radar device.
void(* rlDeviceUnMaskHostIrq)(rlComIfHdl_t fd)
Unmask Host Interrupt.
rlSysNRespType_t errorType
rlUInt8_t retryCount
Retry count for re-sending command if device doesn't send response within timeout or device sends NAC...
rlClientCbs_t clientCtx
Client context.
rlDeviceCtrlCbs_t devCtrlCb
Device Control Callback.
rlReturnVal_t rlDriverAddDevice(rlUInt8_t deviceMap)
Adds mmwave radar device.
mmWaveLink API Error Sub block structure
rlCrcType_t crcType
CRC Types rlCrcType_t 16/32/64.
rlReturnVal_t rlDriverWaitForResponse(rlUInt8_t devIndex, rlDriverMsg_t *outMsg)
: Wait for Device's response
rlUInt8_t deviceMap
Bitmap of devices connected radarSS/DSS Mailbox in case of 16xx autonomous.
rlUInt16_t b4Version
0000 - Invalid, 0001 - 1111 - Valid Range
rlReturnVal_t rlDriverProcRdMsg(rlUInt8_t devIdx, rlReturnVal_t inVal)
Process received message for Async event message.
RHCP SYNC Pattern Structure.
rlComDevInx_t commDevIdx
Communication handle and device-index for deifferent devices connected to Host.
void rlDriverShiftDWord(rlUInt8_t buf[])
Shifts one byte in the byte array.
rlCmdParserCbs_t cmdParserCb
Call back for parsing the Command received at MSS from the Host TI Internal Use only.
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 rlDriverIsDeviceMapValid(rlUInt8_t deviceMap)
Checks if given deviecMap is valid wrt to global DeviceMap set to mmWaveLink.
rlInt32_t(* rlDeviceWaitIrqStatus)(rlComIfHdl_t fd, rlUInt8_t highLow)
Polls Host Interrupt Status.