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_LOGDB_ARG1(
"Device [%d] Host IRQ High\r", deviceIndex);
572 RL_LOGV_ARG0(
"rlDriverHostIrqHandler starts...\n");
575 if (pValue == RL_NULL_PTR)
578 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Input arg is NULL\n");
591 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Mask the Interrupt\n");
603 rlDrvData->isRespWriteWaited[deviceIndex]);
605 if (RL_TRUE == tempVar)
609 &rlDrvData->
cmdSem[deviceIndex]);
610 RL_LOGD_ARG0(
"rlDriverHostIrqHandler Release command response \n");
617 (RL_P_OSI_SPAWN_ENTRY)rlDriverMsgReadSpawnCtx,
619 RL_LOGD_ARG0(
"rlDriverHostIrqHandler No response is expected \n");
622 RL_LOGV_ARG0(
"rlDriverHostIrqHandler ends...\n");
641 rlReturnVal_t retVal;
652 switch (rlDrvData->
funcParams[devIdx].rxMsgClass)
654 case RL_API_CLASS_ASYNC:
656 if (inVal == RL_RET_CODE_OK)
661 rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.hdr.nsbc,\
662 (rlUInt8_t *)&rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.payload[0],\
663 (rlUInt16_t)(rlDrvData->
funcParams[devIdx].asyncEvt.evtMsg.hdr.len - \
668 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
670 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
671 RL_MMWL_AE_MISMATCH_REPORT);
672 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
675 (void)memcpy(&errPayload[2], (rlUInt8_t*) &inVal,
sizeof(rlReturnVal_t));
682 (rlUInt8_t *)&errPayload[0],\
683 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
686 case RL_API_CLASS_NACK:
688 retVal = RL_RET_CODE_OK;
690 case RL_API_CLASS_RSP:
692 retVal = RL_RET_CODE_OK;
695 case RL_API_CLASS_CMD:
696 case RL_API_CLASS_BYPASS:
703 rlDrvData->
funcParams[devIdx].rxMsgClass, inVal);
709 retVal = RL_RET_CODE_OK;
712 case RL_API_CLASS_MAX:
714 retVal = RL_RET_CODE_OK;
718 retVal = RL_RET_CODE_PROTOCOL_ERROR;
719 RL_LOGE_ARG0(
"rlDriverProcRdMsg, Rl protocol error\n");
737 rlReturnVal_t rlDriverMsgReadSpawnCtx(
const void *pValue)
739 rlReturnVal_t retVal, msgRdRetVal;
740 rlUInt8_t deviceIndex;
741 rlUInt8_t lclRxIrqCnt, lclRxDoneCnt;
745 RL_LOGV_ARG0(
"rlDriverMsgReadSpawnCtx starts...\n");
748 if (pValue == RL_NULL_PTR)
752 RL_LOGE_ARG0(
"rlDriverMsgReadSpawnCtx Input arg is NULL\n");
757 deviceIndex = *(
const rlUInt8_t*)pValue;
767 (&rlDrvData->
devMutex[deviceIndex], (rlOsiTime_t)RL_OSI_WAIT_FOREVER))
769 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
771 rlReturnVal_t* ptrData;
774 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
775 RL_MMWL_AE_INTERNALERR_REPORT);
776 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
779 inVal = RL_RET_CODE_RADAR_OSIF_ERROR;
782 if (RL_NULL_PTR != ptrData)
788 (void)memcpy((
void*)&errPayload[2], (
void*)ptrData,
sizeof(rlReturnVal_t));
796 (rlUInt8_t *)&errPayload[0],\
797 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
803 lclRxIrqCnt = rlDrvData->
rxIrqCnt[deviceIndex];
804 lclRxDoneCnt = rlDrvData->
rxDoneCnt[deviceIndex];
807 if (lclRxIrqCnt == lclRxDoneCnt)
811 RL_LOGD_ARG0(
"rlDriverMsgReadSpawnCtx, RxIrqCnt is equal to RxDoneCnt\n");
812 retVal = RL_RET_CODE_OK;
826 (&rlDrvData->
devMutex[deviceIndex]);
829 RL_LOGV_ARG0(
"rlDriverMsgReadSpawnCtx ends...\n");
848 rlReturnVal_t retVal, retStatus;
851 RL_LOGV_ARG0(
"rlDriverMsgCmdReply starts...\n");
859 if (RL_RET_CODE_OK != (rlInt32_t)retStatus)
863 if (RL_API_CLASS_ASYNC == rlDrvData->
funcParams[devIndex].rxMsgClass)
865 rlUInt16_t errPayload[RL_MIN_SBC_LEN + 4U];
867 errPayload[0] = ((RL_MMWL_ASYNC_EVENT_MSG * RL_MAX_SB_IN_MSG) +\
868 RL_MMWL_AE_MISMATCH_REPORT);
869 errPayload[1] = (RL_MIN_SBC_LEN + 4U);
871 (void)memcpy(&errPayload[2], (rlUInt8_t*)&retStatus,
sizeof(rlReturnVal_t));
878 (rlUInt8_t *)&errPayload[0],\
879 (rlUInt16_t)(RL_MIN_SBC_LEN + 4U));
881 if (retStatus == RL_RET_CODE_CRC_FAILED)
885 retStatus = RL_RET_CODE_OK;
891 RL_LOGE_ARG0(
"Error in received data\n");
896 if (RL_API_CLASS_RSP == rlDrvData->
funcParams[devIndex].rxMsgClass)
903 if (rl_rxMsg[devIndex].hdr.opcode.b10MsgId != rl_txMsg[devIndex].hdr.
opcode.
b10MsgId)
906 retVal = RL_RET_CODE_MSGID_MISMATCHED;
907 RL_LOGE_ARG0(
"Msg id is mis-matched\n");
911 if (rl_rxMsg[devIndex].hdr.flags.b4SeqNum != rl_txMsg[devIndex].hdr.flags.
b4SeqNum)
913 retVal = RL_RET_CODE_RX_SEQ_NUM_NOT_MATCH;
914 RL_LOGV_ARG0(
"ACK sequence number is not matching with CMD sequence number\n");
919 retVal = RL_RET_CODE_OK;
927 (&(rlDrvData->
cmdSem[devIndex]), (rlOsiTime_t)RL_OSI_NO_WAIT);
929 else if (RL_API_CLASS_ASYNC == rlDrvData->
funcParams[devIndex].rxMsgClass)
938 rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.hdr.nsbc, \
939 (rlUInt8_t *)&rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.payload[0],
940 (rlUInt16_t)(rlDrvData->
funcParams[devIndex].asyncEvt.evtMsg.hdr.len - \
942 retVal = RL_RET_CODE_OK;
946 else if (RL_API_CLASS_NACK == rlDrvData->
funcParams[devIndex].rxMsgClass)
952 retVal = RL_RET_CODE_NACK_ERROR;
953 RL_LOGE_ARG0(
"CMD CRC check fails, device sends NACK\n");
958 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
959 RL_LOGE_ARG0(
"Invalid Class\n");
962 RL_LOGV_ARG0(
"rlDriverMsgCmdReply ends...\n");
982 rlReturnVal_t retVal;
985 RL_LOGV_ARG0(
"rlDriverMsgReadCmdCtx starts...\n");
987 if (RL_NULL_PTR == rlDrvData)
989 retVal = RL_RET_CODE_FATAL_ERROR;
997 retVal = RL_RET_CODE_OK;
1006 while ((RL_TRUE == rlDrvData->
isCmdRespWaited[devIndex]) && (RL_RET_CODE_OK == retVal))
1008 if (RL_PENDING_RX_MSG(rlDrvData, devIndex))
1012 rlDrvData->
funcParams[devIndex].rxMsgClass = RL_API_CLASS_MAX;
1025 &(rlDrvData->
cmdSem[devIndex]),
1031 RL_LOGE_ARG0(
"CmdSem should be signaled by IRQ but respTimeout\n");
1032 retVal += RL_RET_CODE_RESP_TIMEOUT;
1039 if (RL_PENDING_RX_MSG(rlDrvData, devIndex) && (retVal != RL_RET_CODE_FATAL_ERROR) \
1044 ((RL_P_OSI_SPAWN_ENTRY)rlDriverMsgReadSpawnCtx, \
1047 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
1051 RL_LOGV_ARG0(
"rlDriverMsgReadCmdCtx ends...\n");
1071 static rlReturnVal_t rlDriverOriginDirCheck(rlUInt8_t deviceRunId,
1074 rlReturnVal_t retVal;
1076 RL_LOGV_ARG0(
"rlDriverOriginDirCheck starts...\n");
1078 switch (deviceRunId)
1081 case RL_PLATFORM_HOST:
1082 if ((RL_API_DIR_BSS_TO_HOST == dataDir) ||
1083 (RL_API_DIR_MSS_TO_HOST == dataDir) ||
1084 (RL_API_DIR_DSS_TO_HOST == dataDir))
1088 retVal = RL_RET_CODE_OK;
1093 retVal = RL_RET_CODE_INVALID_INPUT;
1097 case RL_PLATFORM_MSS:
1098 if ((RL_API_DIR_BSS_TO_MSS == dataDir) ||
1099 (RL_API_DIR_DSS_TO_MSS == dataDir) ||
1100 (RL_API_DIR_HOST_TO_MSS == dataDir))
1104 retVal = RL_RET_CODE_OK;
1109 retVal = RL_RET_CODE_INVALID_INPUT;
1113 case RL_PLATFORM_DSS:
1115 if ((RL_API_DIR_BSS_TO_DSS == dataDir) ||
1116 (RL_API_DIR_MSS_TO_DSS == dataDir) ||
1117 (RL_API_DIR_HOST_TO_DSS == dataDir))
1121 retVal = RL_RET_CODE_OK;
1126 retVal = RL_RET_CODE_INVALID_INPUT;
1131 retVal = RL_RET_CODE_INVALID_INPUT;
1132 RL_LOGE_ARG2(
"Unknown platform %d, retVal = %d\n", \
1136 RL_LOGV_ARG0(
"rlDriverOriginDirCheck ends...\n");
1141 rlReturnVal_t rlDriverRdVerifyMsg(
rlReadBuf_t readBuf, rlUInt8_t devIndex)
1143 rlUInt16_t rxLengthRecv;
1144 rlReturnVal_t retVal, readRetVal;
1145 rlUInt16_t payloadLen, msgCrcLen, msgCrcType;
1146 rlUInt8_t isCrcPresent;
1149 rxLengthRecv = RL_RHCP_HDR_PL_LENGTH(&(readBuf.syncHeader.protHdr));
1152 if (rxLengthRecv >= (RL_MAX_SIZE_MSG - SYNC_PATTERN_LEN))
1154 retVal = RL_RET_CODE_PROTOCOL_ERROR;
1162 rl_driverData.
funcParams[devIndex].rxMsgClass =
1163 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1166 payloadLen = rxLengthRecv - (rlUInt16_t)RHCP_HEADER_LEN;
1168 if (RL_API_CLASS_ASYNC == rl_driverData.
funcParams[devIndex].rxMsgClass)
1174 rhcpMsg = &rl_driverData.
funcParams[devIndex].asyncEvt.evtMsg;
1179 rhcpMsg = &rl_rxMsg[devIndex];
1183 rhcpMsg->hdr = readBuf.syncHeader.protHdr;
1185 rhcpMsg->syncPattern = readBuf.syncHeader.syncPattern;
1188 if (rhcpMsg->hdr.flags.
b2Crc != 0U)
1191 isCrcPresent = RL_FALSE;
1197 isCrcPresent = RL_TRUE;
1199 msgCrcType = rhcpMsg->hdr.flags.
b2CrcLen;
1201 msgCrcLen = (2U << (msgCrcType & 0x3U));
1204 payloadLen = ((isCrcPresent == RL_TRUE) ? (payloadLen - msgCrcLen) : payloadLen);
1207 if (payloadLen > 0U)
1210 &rhcpMsg->payload[0U], payloadLen) != (rlInt32_t)payloadLen)
1213 readRetVal = RL_RET_CODE_RADAR_IF_ERROR;
1217 readRetVal = RL_RET_CODE_OK;
1219 #if !(RL_DISABLE_LOGGING) 1226 readRetVal = RL_RET_CODE_OK;
1230 if ((isCrcPresent == RL_TRUE) && (readRetVal == RL_RET_CODE_OK))
1235 msgCrcLen) != (rlInt32_t)msgCrcLen)
1238 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1242 (void)memcpy(&rhcpMsg->payload[payloadLen], \
1243 &rl_driverData.
funcParams[devIndex].msgCRC[0U], msgCrcLen);
1246 if ((rl_driverData.
clientCtx.
crcType != (rlUInt8_t)RL_CRC_TYPE_NO_CRC) && \
1254 msgCrcLen), (rlUInt8_t)(msgCrcType), \
1259 retVal = RL_RET_CODE_OK;
1262 #if !(RL_DISABLE_LOGGING) 1269 retVal = RL_RET_CODE_OK;
1291 rlReturnVal_t retVal, hdrRetVal;
1293 rlUInt16_t payloadLen;
1295 RL_LOGV_ARG0(
"rlDriverMsgRead starts...\n");
1297 if (RL_NULL_PTR == rlDrvData)
1300 retVal = RL_RET_CODE_FATAL_ERROR;
1304 rlReturnVal_t hdrType;
1309 RL_LOGV_ARG1(
"rlDriverRxHdrRead return val = %d\n", hdrType);
1313 if (SYNC_PATTERN_MATCHED == (rlInt32_t)(hdrType))
1321 if ((RL_RET_CODE_OK == hdrRetVal) && (RL_RET_CODE_OK == \
1323 (rlUInt8_t)readBuf.syncHeader.protHdr.opcode.b4Direction)))
1325 retVal = rlDriverRdVerifyMsg(readBuf, devIndex);
1327 else if (RL_RET_CODE_OK == hdrRetVal)
1329 rlDrvData->
funcParams[devIndex].rxMsgClass = RL_API_CLASS_BYPASS;
1334 rl_rxMsg[devIndex].syncPattern = readBuf.syncHeader.syncPattern;
1335 rl_rxMsg[devIndex].hdr = readBuf.syncHeader.protHdr;
1338 payloadLen = readBuf.syncHeader.protHdr.len - (rlUInt16_t)RHCP_HEADER_LEN;
1342 &rl_rxMsg[devIndex].payload[0], payloadLen) != (rlInt32_t)payloadLen)
1345 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1350 retVal = RL_RET_CODE_OK;
1352 #if !(RL_DISABLE_LOGGING) 1360 else if ((RL_RET_CODE_CHKSUM_FAILED == hdrRetVal) && \
1363 rlUInt16_t dummyToFlushSpi[8U] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
1364 0xFFFF, 0xFFFF, 0xFFFF};
1370 for (readCnt = 1U; readCnt < (SYNC_PATTERN_LEN + RHCP_HEADER_LEN); readCnt++)
1373 (rlUInt8_t*)&dummyToFlushSpi[0U], (SYNC_PATTERN_LEN + \
1376 #if !(RL_DISABLE_LOGGING) 1378 (rlUInt8_t*)&dummyToFlushSpi[0U], (SYNC_PATTERN_LEN + \
1379 RHCP_HEADER_LEN), RL_SPI_LOG_READ);
1382 if (rl_txMsg[devIndex].hdr.flags.b2Crc == 0U)
1386 (rlUInt8_t*)&dummyToFlushSpi[0U], msgCrcLen);
1388 #if !(RL_DISABLE_LOGGING) 1394 rl_driverData.
funcParams[devIndex].rxMsgClass = RL_API_CLASS_ASYNC;
1404 rl_driverData.
funcParams[devIndex].rxMsgClass =
1405 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1409 else if (CNYS_PATTERN_MATCHED == (rlInt32_t)(hdrType))
1420 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1427 if (hdrType == RL_RET_CODE_HOSTIRQ_TIMEOUT)
1429 rl_driverData.
funcParams[devIndex].rxMsgClass = RL_API_CLASS_ASYNC;
1434 rl_driverData.
funcParams[devIndex].rxMsgClass =
1435 RL_RHCP_HDR_OPCODE_CLASS(&(readBuf.syncHeader.protHdr));
1441 (retVal != RL_RET_CODE_FATAL_ERROR))
1446 RL_LOGD_ARG0(
"rlDriverMsgRead Unmask Interrupt call\n");
1450 RL_LOGV_ARG0(
"rlDriverMsgRead ends...\n");
1470 rlComIfHdl_t comIfHdl)
1472 rlReturnVal_t retVal;
1474 RL_LOGV_ARG0(
"rlDriverMsgWrite starts...\n");
1477 if (((rlComIfHdl_t)RL_NULL != comIfHdl) && (rlDrvData != RL_NULL_PTR))
1479 rlUInt16_t checkSum = 0U, msgCrcLen;
1480 rlUInt16_t payloadLen;
1485 (void)rlDriverCalChkSum(&rl_txMsg[devIndex].hdr, ((rlUInt8_t)(RHCP_HEADER_LEN - 2U)),
1487 rl_txMsg[devIndex].hdr.chksum = checkSum;
1490 payloadLen = rl_txMsg[devIndex].hdr.len - (rlUInt16_t)RHCP_HEADER_LEN;
1491 RL_LOGV_ARG1(
"API Dir = %d \n", rl_txMsg[devIndex].hdr.opcode.b4Direction);
1494 if ((RL_API_DIR_DSS_TO_HOST == rl_txMsg[devIndex].hdr.opcode.b4Direction) || \
1499 rl_txMsg[devIndex].syncPattern.sync1 = D2H_SYNC_PATTERN_1;
1500 rl_txMsg[devIndex].syncPattern.sync2 = D2H_SYNC_PATTERN_2;
1505 rl_txMsg[devIndex].syncPattern.sync1 = H2D_SYNC_PATTERN_1;
1506 rl_txMsg[devIndex].syncPattern.sync2 = H2D_SYNC_PATTERN_2;
1510 if (rl_txMsg[devIndex].hdr.flags.b2Crc == RL_HDR_FLAG_CRC)
1519 (rl_txMsg[devIndex].hdr.len - msgCrcLen),
1523 (void)memcpy((rlUInt8_t*)(&rl_txMsg[devIndex].payload[payloadLen - msgCrcLen]),
1524 (rlUInt8_t*)&(rlDrvData->
funcParams[devIndex].msgCRC[0]), msgCrcLen);
1526 tempLen = ((rlUInt16_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN) + payloadLen);
1530 if (RL_IF_WRITE(comIfHdl, ((rlUInt8_t *)&rl_txMsg[devIndex]), \
1531 tempLen) != (rlInt32_t)tempLen)
1534 retVal = RL_RET_CODE_RADAR_IF_ERROR;
1539 retVal = RL_RET_CODE_OK;
1541 #if !(RL_DISABLE_LOGGING) 1549 retVal = RL_RET_CODE_FATAL_ERROR;
1551 RL_LOGV_ARG0(
"rlDriverMsgWrite ends...\n");
1571 static rlUInt8_t rlDriverReceiveSync(rlComIfHdl_t comIfHdl, rlUInt8_t syncBuf[],
1572 rlInt32_t *syncType)
1574 rlUInt8_t count = 0;
1577 rlReturnVal_t errVal;
1579 RL_LOGV_ARG0(
"rlDriverReceiveSync starts...\n");
1582 if (syncType != (rlInt32_t*)RL_NULL)
1585 if (RL_IF_READ(comIfHdl, &syncBuf[0U], (rlUInt16_t)SYNC_PATTERN_LEN) != \
1586 (rlInt32_t)SYNC_PATTERN_LEN)
1589 errVal = RL_RET_CODE_RADAR_IF_ERROR;
1594 (void)memcpy(&recSyncPattern, &syncBuf[0U], SYNC_PATTERN_LEN);
1595 errVal = RL_RET_CODE_OK;
1597 #if !(RL_DISABLE_LOGGING) 1599 (rlUInt16_t)SYNC_PATTERN_LEN, RL_SPI_LOG_READ);
1601 retVal = PATTERN_NOT_MATCHED;
1604 while (((retVal) == (rlInt32_t)PATTERN_NOT_MATCHED) && (errVal == RL_RET_CODE_OK))
1607 if (((recSyncPattern.sync1 == H2D_SYNC_PATTERN_1) &&
1608 (recSyncPattern.sync2 == H2D_SYNC_PATTERN_2) ) || \
1609 ((recSyncPattern.sync1 == D2H_SYNC_PATTERN_1) &&
1610 (recSyncPattern.sync2 == D2H_SYNC_PATTERN_2)))
1614 retVal = SYNC_PATTERN_MATCHED;
1620 if ((recSyncPattern.sync1 == H2D_CNYS_PATTERN_1) &&
1621 (recSyncPattern.sync2 == H2D_CNYS_PATTERN_2))
1625 retVal = CNYS_PATTERN_MATCHED;
1628 else if (count >= (rlUInt16_t)RL_SYNC_SCAN_THRESHOLD)
1633 if (RL_IF_READ(comIfHdl, &syncBuf[SYNC_PATTERN_LEN], (rlUInt16_t)crcLen) != \
1637 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1642 errVal += RL_RET_CODE_PROTOCOL_ERROR;
1644 #if !(RL_DISABLE_LOGGING) 1646 &syncBuf[SYNC_PATTERN_LEN], (rlUInt16_t)crcLen, \
1653 if (0 == (count % SYNC_PATTERN_LEN))
1656 if (RL_IF_READ(comIfHdl, &syncBuf[SYNC_PATTERN_LEN],\
1657 (rlUInt16_t)SYNC_PATTERN_LEN) != \
1658 (rlInt32_t)SYNC_PATTERN_LEN)
1661 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1664 #if !(RL_DISABLE_LOGGING) 1666 &syncBuf[SYNC_PATTERN_LEN], (rlUInt16_t)SYNC_PATTERN_LEN, \
1673 (void)memcpy(&recSyncPattern, &syncBuf[0U], SYNC_PATTERN_LEN);
1680 if (errVal == RL_RET_CODE_OK)
1682 *(syncType) = retVal;
1686 *(syncType) = errVal;
1689 count %= SYNC_PATTERN_LEN;
1690 RL_LOGV_ARG1(
"rlDriverReceiveSync, count = %d\n", count);
1691 RL_LOGV_ARG0(
"rlDriverReceiveSync ends...\n");
1717 rlUInt8_t syncBuf[SYNC_PATTERN_LEN * 2] = {0U};
1723 rlUInt16_t cnysBuf[8U] = {H2D_CNYS_PATTERN_1, H2D_CNYS_PATTERN_2,
1724 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU, 0xFFFFU};
1725 rlInt32_t syncType = PATTERN_NOT_MATCHED;
1729 RL_LOGV_ARG0(
"rlDriverRxHdrRead starts...\n");
1732 if ((rlComIfHdl_t)RL_NULL == comIfHdl)
1734 errVal = RL_RET_CODE_FATAL_ERROR;
1743 if (RL_IF_WRITE(comIfHdl,
1744 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN)) !=\
1745 (rlInt32_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN))
1748 errVal = RL_RET_CODE_RADAR_IF_ERROR;
1752 errVal = RL_RET_CODE_OK;
1754 #if !(RL_DISABLE_LOGGING) 1756 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN),\
1760 RL_LOGV_ARG2(
"Platform = %d, delay = %d \n",\
1767 0U) != RL_RET_CODE_OK) && (errVal == RL_RET_CODE_OK))
1770 if (RL_IF_WRITE(comIfHdl,
1771 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN)) !=\
1772 (rlInt32_t)(SYNC_PATTERN_LEN + RHCP_HEADER_LEN))
1775 errVal += RL_RET_CODE_RADAR_IF_ERROR;
1781 errVal += RL_RET_CODE_HOSTIRQ_TIMEOUT;
1784 #if !(RL_DISABLE_LOGGING) 1786 (rlUInt8_t*)&cnysBuf[0U], (rlUInt16_t)(SYNC_PATTERN_LEN+ RHCP_HEADER_LEN),\
1802 errVal = RL_RET_CODE_OK;
1805 if (errVal == RL_RET_CODE_OK)
1807 RL_LOGDB_ARG1(
"Device [%d] Host IRQ Low\r", *((rlUInt8_t*)comIfHdl));
1811 syncCnt = rlDriverReceiveSync(comIfHdl, &syncBuf[0U], &syncType);
1812 RL_LOGV_ARG1(
"syncType = %d \n", syncType);
1814 if ((CNYS_PATTERN_MATCHED == syncType) || (SYNC_PATTERN_MATCHED == syncType))
1817 rlUInt8_t* payloadBuf;
1819 payloadBuf = &syncBuf[0U];
1820 if (RL_NULL_PTR != payloadBuf)
1825 (void)memcpy(&hdrBuf[0], payloadBuf, (SYNC_PATTERN_LEN + syncCnt));
1827 tempLen = RHCP_HEADER_LEN - (0x00FFU & syncCnt);
1829 if (RL_IF_READ(comIfHdl, (&hdrBuf[(SYNC_PATTERN_LEN + syncCnt)]), \
1830 tempLen) != (rlInt32_t)tempLen)
1832 syncType += RL_RET_CODE_RADAR_IF_ERROR;
1834 #if !(RL_DISABLE_LOGGING) 1836 (&hdrBuf[(SYNC_PATTERN_LEN + syncCnt)]), tempLen,\
1843 RL_LOGD_ARG0(
"do nothing ");
1853 RL_LOGV_ARG0(
"rlDriverRxHdrRead ends...\n");
1870 rlReturnVal_t retVal;
1871 rlInt32_t funcRetVal = RL_RET_CODE_OK;
1873 rlInt8_t CmdSemStr[9] =
"CmdSem_";
1874 rlInt8_t devMutexStr[11] =
"devMutex_";
1876 for (index = 0U; index < RL_CASCADE_NUM_DEVICES; index++)
1881 CmdSemStr[7] = (rlInt8_t)(index+48U);
1884 CmdSemStr[8] = (rlInt8_t)
'\0';
1886 &rl_driverData.
cmdSem[index], CmdSemStr);
1891 devMutexStr[9] = (rlInt8_t)(index+48U);
1894 devMutexStr[10] = (rlInt8_t)
'\0';
1896 &rl_driverData.
devMutex[index], devMutexStr);
1900 if (funcRetVal != RL_RET_CODE_OK)
1903 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
1907 retVal = RL_RET_CODE_OK;
1913 static rlReturnVal_t rlDriverOsiCbCheck(
rlClientCbs_t clientCb)
1915 rlReturnVal_t retVal;
1918 if ((RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexCreate) ||
1919 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexLock ) ||
1920 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexUnLock) ||
1921 (RL_NULL_PTR == clientCb.
osiCb.
mutex.rlOsiMutexDelete))
1923 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1926 else if ((RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemCreate) ||
1927 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemWait ) ||
1928 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemSignal) ||
1929 (RL_NULL_PTR == clientCb.
osiCb.
sem.rlOsiSemDelete))
1931 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1939 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1944 retVal = RL_RET_CODE_OK;
1959 static rlReturnVal_t rlDriverClientCbCheck(
rlClientCbs_t clientCb)
1961 rlReturnVal_t retVal;
1963 if (RL_RET_CODE_OK != rlDriverOsiCbCheck(clientCb))
1965 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1973 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1976 else if (((clientCb.
platform == RL_PLATFORM_HOST) &&
1978 (RL_NULL_PTR == clientCb.
timerCb.rlDelay)))) ||
1979 (RL_NULL_PTR == clientCb.
osiCb.
queue.rlOsiSpawn))
1981 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1985 (RL_NULL_PTR == clientCb.
devCtrlCb.rlRegisterInterruptHandler) ||
1986 ((RL_CRC_TYPE_NO_CRC != clientCb.
crcType) &&
1987 (RL_NULL_PTR == clientCb.
crcCb.rlComputeCRC)))
1989 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
1993 retVal = RL_RET_CODE_OK;
2012 rlReturnVal_t rlDriverInit(rlUInt8_t deviceMap,
rlClientCbs_t clientCb)
2014 rlReturnVal_t retVal, cbCheck;
2015 rlUInt8_t index = 0U;
2018 cbCheck = rlDriverClientCbCheck(clientCb);
2020 if (RL_RET_CODE_OK != cbCheck)
2025 else if (deviceMap <= ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U))
2028 for (; index < RL_DEVICE_CONNECTED_MAX; index++)
2033 rl_driverData.
rxIrqCnt[index] = 0U;
2036 for (index = 0U; index < RL_CASCADE_NUM_DEVICES; index++)
2038 rl_driverData.
txMsgPtr[index] = &rl_txMsg[index];
2039 rl_driverData.
rxMsgPtr[index] = &rl_rxMsg[index];
2047 rl_driverData.
retryCount = RL_API_CMD_RETRY_COUNT;
2052 #if !(RL_DISABLE_LOGGING) 2053 if (RL_RET_CODE_OK == retVal)
2056 retVal += rlLogInit();
2057 RL_LOGV_ARG0(
"Logging is enabled \n");
2065 if (((deviceMap & (1U << index)) != 0U) && (retVal == RL_RET_CODE_OK))
2078 retVal += RL_RET_CODE_RADAR_IF_ERROR;
2085 (
void*)RL_NULL) != RL_RET_CODE_OK)
2087 retVal +=RL_RET_CODE_RADAR_IF_ERROR;
2091 deviceMap &= ~(1U << index);
2094 if (retVal != RL_RET_CODE_OK)
2103 while ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));
2107 retVal = RL_RET_CODE_INVALID_INPUT;
2108 RL_LOGE_ARG0(
"Invaid input argument\n");
2112 if (retVal == RL_RET_CODE_OK)
2115 RL_LOGD_ARG0(
"Driver init flag is set\n");
2119 RL_LOGE_ARG0(
"rlDriverInit, Init failed\n");
2138 rlReturnVal_t retVal;
2139 rlUInt8_t index = 0U;
2141 RL_LOGV_ARG0(
"rlDriverAddDevice starts\n");
2144 (deviceMap <= ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U)))
2152 if ((deviceMap & (1U << index)) != 0U)
2160 rl_driverData.clientCtx.comIfCb.rlComIfOpen(index, 0U);
2167 (
void*)RL_NULL) != RL_RET_CODE_OK) ||
2171 retVal = RL_RET_CODE_RADAR_IF_ERROR;
2175 retVal = RL_RET_CODE_OK;
2180 retVal =RL_RET_CODE_RADAR_IF_ERROR;
2182 deviceMap &= ~(1U << index);
2186 retVal = RL_RET_CODE_OK;
2190 if (RL_RET_CODE_OK != retVal)
2197 while ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));
2201 if (deviceMap > ((1U << RL_DEVICE_CONNECTED_MAX) - 0x1U))
2203 retVal = RL_RET_CODE_INVALID_INPUT;
2204 RL_LOGE_ARG0(
"Invalid input argument\n");
2208 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2209 RL_LOGE_ARG0(
"rlDriverAddDevice, Invalid state \n");
2212 RL_LOGV_ARG0(
"rlDriverAddDevice completes\n");
2232 rlReturnVal_t retVal = RL_RET_CODE_OK;
2234 RL_LOGV_ARG0(
"rlDriverRemoveDevices starts...\n");
2239 for (index = 0U; ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));\
2242 if ((deviceMap & (1U << index)) != 0U)
2254 index, RL_NULL, RL_NULL);
2256 deviceMap &= ~(1U << index);
2259 RL_LOGV_ARG0(
"rlDriverRemoveDevices completes\n");
2276 rlUInt8_t index, devCnt;
2277 rlUInt8_t deviceMap = rl_driverData.
deviceMap;
2278 rlReturnVal_t retVal = RL_RET_CODE_OK;
2280 RL_LOGV_ARG0(
"rlDriverDeInit starts...\n");
2282 for (index = 0U; ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));\
2285 if ((deviceMap & (1U << index)) != 0U)
2297 index, RL_NULL, RL_NULL);
2299 deviceMap &= ~(1U << index);
2303 for (devCnt = 0U; devCnt < RL_CASCADE_NUM_DEVICES; devCnt++)
2310 rl_driverData.
devMutex[devCnt] = RL_NULL_PTR;
2312 RL_LOGD_ARG0(
"Destroy Per CMD Mutex\n");
2315 if (rl_driverData.
cmdSem[devCnt] != RL_NULL_PTR)
2318 &rl_driverData.
cmdSem[devCnt]);
2319 rl_driverData.
cmdSem[devCnt] = RL_NULL_PTR;
2320 RL_LOGD_ARG0(
"Destroy Command Semaphore\n");
2326 RL_LOGV_ARG0(
"rlDriverDeInit ends...\n");
2344 return (&rl_driverData);
2359 RL_LOGV_ARG0(
"rlDriverGetPlatformId is called \n");
2377 RL_LOGV_ARG0(
"rlDriverGetArDeviceType is called \n");
2396 rlUInt8_t storedDevMap;
2397 rlReturnVal_t retVal;
2399 RL_LOGV_ARG0(
"rlDriverIsDeviceMapValid starts \n");
2404 if ((storedDevMap & deviceMap) != 0U)
2413 RL_LOGE_ARG0(
"Device map is In-valid \n");
2415 RL_LOGV_ARG0(
"rlDriverIsDeviceMapValid ends \n");
2440 rlUInt16_t rspChunks;
2442 rlReturnVal_t retVal, retVal1;
2444 rlUInt8_t payloadLen = 0U;
2446 RL_LOGV_ARG0(
"rlDriverWaitForResponse starts... \n");
2452 if (RL_RET_CODE_OK == retVal1)
2455 rspChunks = rl_rxMsg[devIndex].hdr.remChunks;
2458 if (outMsg->opcode.
nsbc >= rl_rxMsg[devIndex].hdr.nsbc)
2460 outMsg->opcode.
nsbc = rl_rxMsg[devIndex].hdr.nsbc;
2462 for (indx = 0U; indx < (outMsg->opcode.
nsbc); indx++)
2467 (void)rlGetSubBlock(rl_rxMsg[devIndex].payload + payloadLen,
2468 &(outMsg->subblocks[indx].sbid),
2469 &(outMsg->subblocks[indx].len),
2470 outMsg->subblocks[indx].pSblkData);
2471 payloadLen += (rlUInt8_t)(outMsg->subblocks[indx].len);
2477 else if (RL_RET_CODE_MSGID_MISMATCHED == retVal1)
2483 rlErrorResp_t errMsgSbData = {(rlSysNRespType_t)0U, (rlUInt16_t)0U};
2487 errorSB.pSblkData = (rlUInt8_t* )&errMsgSbData;
2492 (void)rlGetSubBlock(rl_rxMsg[devIndex].payload + payloadLen,
2493 &(errorSB.sbid), &(errorSB.len),
2497 retVal = (rlReturnVal_t)(errMsgSbData.
errorType);
2500 RL_LOGE_ARG0(
"msg id mis-match, command failure\n");
2508 RL_LOGE_ARG0(
"Timeout in receiving response\n");
2511 while (rspChunks > 0U);
2513 RL_LOGV_ARG0(
"rlDriverWaitForResponse ends... \n");
2518 static rlReturnVal_t rlDriverCmdWriter(rlUInt8_t devIndex,
rlDriverMsg_t* outMsg)
2520 rlReturnVal_t retVal;
2521 rlUInt8_t retryCount = 0U;
2523 rlUInt8_t isPayloadValid = RL_FALSE, isNackRetry = RL_FALSE;
2527 if ((retryCount != 0U) && (isNackRetry == RL_FALSE))
2549 if (RL_RET_CODE_OK == retVal)
2556 RL_LOGD_ARG0(
"rlDriverCmdWriter, wait for respond\n");
2560 if ((RL_RET_CODE_OK == retVal) || \
2561 ((RL_RET_CODE_CRC_FAILED != retVal) && \
2562 (RL_RET_CODE_RESP_TIMEOUT != retVal)))
2572 if (RL_RET_CODE_NACK_ERROR == retVal)
2575 isNackRetry = RL_TRUE;
2588 isPayloadValid = RL_TRUE;
2590 isNackRetry = RL_FALSE;
2596 isNackRetry = RL_FALSE;
2609 RL_LOGE_ARG0(
"rlDriverCmdWriter, Error in cmd msg write\n");
2613 while ((retryCount < (rl_driverData.
retryCount + 1U)) && (isPayloadValid == RL_FALSE));
2634 rlReturnVal_t retVal;
2637 if (rlDrvData == RL_NULL)
2639 retVal = RL_RET_CODE_FATAL_ERROR;
2643 retVal = RL_RET_CODE_OK;
2658 retVal += rlDriverCmdWriter(devIndex, outMsg);
2679 static void rlDriverAppendDummyByte(rlUInt8_t devIndex)
2681 rlUInt8_t protAlignSize;
2682 rlUInt16_t msgCrcLen;
2689 protAlignSize = (rl_driverData.
clientCtx.
crcType < RL_CRC_TYPE_64BIT_ISO) ? \
2690 RL_PAYLOAD_MSG_4BYTE_MULT : RL_PAYLOAD_MSG_8BYTE_MULT;
2693 if (rl_driverData.
txMsgPtr[devIndex] != RL_NULL_PTR)
2696 if ((rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize) != 0U)
2708 (void)rlAppendDummy((rlUInt8_t*)(((rlUInt8_t*)rl_driverData.
txMsgPtr[devIndex]) + \
2709 rl_driverData.txMsgPtr[devIndex]->hdr.len + SYNC_PATTERN_LEN), \
2710 (rlUInt8_t)(protAlignSize - \
2711 (rlUInt8_t)(rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize)));
2712 rl_driverData.
txMsgPtr[devIndex]->hdr.len += (rlUInt16_t)(protAlignSize - \
2713 (rlUInt16_t)(rl_driverData.
txMsgPtr[devIndex]->hdr.len % protAlignSize));
2716 rl_driverData.
txMsgPtr[devIndex]->hdr.len += msgCrcLen;
2742 rlReturnVal_t retVal = RL_RET_CODE_OK;
2743 rlUInt8_t devIndex = 0U;
2745 rlUInt16_t payloadLen;
2747 RL_LOGV_ARG0(
"rlDriverCmdInvoke starts... \n");
2754 while ((deviceMap != 0U) && (RL_RET_CODE_OK == retVal))
2756 if ((deviceMap & (1U << devIndex)) != 0U)
2760 (&(rl_driverData.
devMutex[devIndex]), (rlOsiTime_t)RL_OSI_WAIT_FOREVER))
2764 retVal = RL_RET_CODE_RADAR_OSIF_ERROR;
2768 rlReturnVal_t retVal1 = RL_RET_CODE_OK;
2779 (inMsg.opcode.
msgId & 0x3FFU));
2780 rl_txMsg[devIndex].hdr.remChunks = inMsg.remChunks;
2781 rl_txMsg[devIndex].hdr.nsbc = inMsg.opcode.
nsbc;
2782 rl_txMsg[devIndex].hdr.flags.
b2AckFlag = 0U;
2783 rl_txMsg[devIndex].hdr.flags.
b2Crc = 0U;
2784 rl_txMsg[devIndex].hdr.flags.
b2CrcLen = 0U;
2786 rl_txMsg[devIndex].hdr.flags.
b4SeqNum = 0U;
2787 rl_txMsg[devIndex].hdr.flags.
b4Version = 0U;
2790 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2793 retVal1 += rlAppendSubBlock(&rl_txMsg[devIndex].payload[payloadLen],
2794 inMsg.subblocks[indx].sbid,
2795 inMsg.subblocks[indx].len,
2796 inMsg.subblocks[indx].pSblkData);
2799 payloadLen += inMsg.subblocks[indx].len + \
2800 (rlUInt16_t)(RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE);
2801 if (RL_RET_CODE_OK != retVal1)
2808 if (indx == inMsg.opcode.
nsbc)
2810 rl_txMsg[devIndex].hdr.len = RHCP_HEADER_LEN + payloadLen;
2816 rl_txMsg[devIndex].hdr.flags.
b2AckFlag = RL_HDR_FLAG_NO_ACK;
2823 rl_txMsg[devIndex].hdr.flags.
b2Crc = RL_HDR_FLAG_NO_CRC;
2827 if (rl_txMsg[devIndex].hdr.flags.b2Crc == RL_HDR_FLAG_CRC)
2829 rlDriverAppendDummyByte(devIndex);
2835 &(rl_driverData.
devMutex[devIndex]));
2842 deviceMap &= ~(1U << devIndex);
2849 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2850 RL_LOGE_ARG0(
"rlDriverCmdInvoke, Invalid input \n");
2853 RL_LOGV_ARG0(
"rlDriverCmdInvoke ends... \n");
2869 rlReturnVal_t retVal;
2871 RL_LOGV_ARG0(
"rlDriverConfigureCrc starts... \n");
2877 RL_LOGD_ARG0(
"rlDriverConfigureCrc is success\n");
2878 retVal = RL_RET_CODE_OK;
2883 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2885 RL_LOGV_ARG0(
"rlDriverConfigureCrc ends... \n");
2903 rlReturnVal_t retVal;
2905 RL_LOGV_ARG0(
"rlDriverConfigureAckTimeout starts... \n");
2911 RL_LOGD_ARG0(
"rlDriverConfigureAckTimeout is success\n");
2912 retVal = RL_RET_CODE_OK;
2917 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
2919 RL_LOGV_ARG0(
"rlDriverConfigureAckTimeout ends... \n");
2936 rlPrintFptr rlGetLogFptr(rlUInt8_t dbgLevel)
2938 rlPrintFptr retFuncPtr;
2942 retFuncPtr = rl_driverData.
logObj.rlPrintAr[dbgLevel - (rlUInt8_t)1U];
2947 retFuncPtr = RL_NULL_PTR;
2964 rlReturnVal_t rlLogInit(
void)
2966 rlReturnVal_t retVal;
2969 rlUInt8_t level, idx;
2976 if (fPtr != RL_NULL_PTR)
2980 case RL_DBG_LEVEL_VERBOSE :
2981 case RL_DBG_LEVEL_DEBUG :
2982 case RL_DBG_LEVEL_INFO :
2983 case RL_DBG_LEVEL_WARNING :
2984 case RL_DBG_LEVEL_ERROR :
2985 case RL_DBG_LEVEL_DATABYTE:
2986 for (idx = level; idx > RL_DBG_LEVEL_NONE; idx--)
2988 rlDrvData->
logObj.rlPrintAr[idx - 1U] = fPtr;
2991 case RL_DBG_LEVEL_NONE :
2993 (void)fPtr(
"INFO: MMWAVELINK Logging is disabled\n");
3000 (void)fPtr(
"INFO: Invalid MMWAVELINK Logging, hence disbled\n");
3009 retVal = RL_RET_CODE_OK;
3015 retVal = RL_RET_CODE_INTERFACE_CB_NULL;
3040 inMsg->opcode.
nsbc = 1U;
3041 inMsg->opcode.
msgType = RL_API_CLASS_CMD;
3042 inMsg->opcode.
msgId = msgId;
3043 inMsg->remChunks = 0U;
3046 inMsg->opcode.
dir = cmdDir;
3047 inMsg->subblocks = payloadPtr;
3052 RL_LOGV_ARG0(
"rlDriverConstructInMsg construct InMsg failed!!!\n");
3075 outMsg->opcode.
nsbc = numSblk;
3077 outMsg->subblocks = payloadPtr;
3082 RL_LOGV_ARG0(
"rlDriverConstructOutMsg construct OutMsg failed!!!\n");
3100 rlUInt8_t* data, rlUInt16_t inLen)
3103 if (payloadPtr != NULL)
3106 payloadPtr->sbid = (rlUInt16_t)RL_GET_UNIQUE_SBID(msgId, sbcID);
3109 payloadPtr->len = inLen;
3111 payloadPtr->pSblkData = data;
3115 RL_LOGV_ARG0(
"rlDriverFillPayload data fill failed!!!\n");
3133 rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
3136 rlReturnVal_t retVal;
3189 rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
3192 rlReturnVal_t retVal;
3232 rlReturnVal_t retVal;
3234 RL_LOGV_ARG0(
"rlDriverSetRetryCount starts... \n");
3238 if (retryCnt <= RL_API_CMD_RETRY_COUNT)
3242 RL_LOGD_ARG0(
"rlDriverSetRetryCount is success\n");
3243 retVal = RL_RET_CODE_OK;
3250 retVal = RL_RET_CODE_INVALID_INPUT;
3256 retVal = RL_RET_CODE_INVALID_STATE_ERROR;
3258 RL_LOGV_ARG0(
"rlDriverSetRetryCount ends... \n");
3279 rlUInt32_t BufferLength, rlUInt8_t readEn)
3281 rlUInt8_t tempBuff[2048] = {0};
3282 rlInt32_t offset = 0, index = 0, tempIdx;
3284 while (index < (rlInt32_t)BufferLength)
3288 tempIdx = sprintf((rlInt8_t*)&tempBuff[offset],
"0x%02X%02X ", \
3289 pBuffer[index + 1], pBuffer[index]);
3293 sprintf((rlInt8_t*)&tempBuff[offset],
"\r");
3295 if (readEn == RL_SPI_LOG_WRITE)
3297 RL_LOGDB_ARG2(
"Device [%d] [WR]%s", deviceIdx, tempBuff);
3301 RL_LOGDB_ARG2(
"Device [%d] [RD]%s", deviceIdx, tempBuff);
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
void rlLogSpiReadWrite(rlUInt8_t deviceIdx, rlUInt8_t *pBuffer, rlUInt32_t BufferLength, rlUInt8_t readEn)
: Logging SPI Read/Write command
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/xWR6243 + HOST = 0x0, xWR1443 MSS = 0x1, xWR1642 MSS/DSS = 0x2, xWR1843 MSS/DSS = 0...
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.