/******************************************************************************/ /* Copyright (c) 2016 MD Automotive Controls. Original Work. */ /* License: http://www.gnu.org/licenses/gpl.html GPL version 2 or higher */ /******************************************************************************/ /* CONTEXT:KERNEL */ /* PACKAGE TITLE: XXX */ /* DESCRIPTION: XXX */ /* FILE NAME: XXX.c */ /* REVISION HISTORY: 19-08-2016 | 1.0 | Initial revision */ /* */ /******************************************************************************/ #include #include #include #include #include "peruart.h" #include "PROTAPI.h" #include "IOAPI.h" #include "OS.h" #include "DLL.h" #include "perCAN.h" #include "PACKEDDLL.h" #include "UDSNL.h" #include "CBYTEQUEUE.h" #include "USERMATH.h" #include "RESM.h" extern void VCOMHA_vSend(IOAPI_tenEHIOResource, puint8, uint32); #ifdef BUILD_ENET const uint32 ETH_ru32SourceIPAddress = ETH_nSourceIPAddress; const uint32 ETH_ru32DestinationIPAddress = ETH_nDestinationIPAddress; #endif //BUILD_ENET const uint16 DLL_rau16TXFrameMaxBytes[] = DLL_nMaxTXFrameBytes; IOAPI_tstPortConfigCB DLL_astPortConfigCB[DLL_nVirtualChannelCount]; DLL_tstRXDLLData DLL_stRXDLLData[DLL_nVirtualChannelCount]; uint16 DLL_au16PacketSeq[DLL_nVirtualChannelCount]; /* Circular TX queues */ uint8 DLL_au8ByteIICByteQueue[DLL_nIICVirtualChannelCount][DLL_nIICTXQueueByteCount]; uint8 DLL_au8ByteSPIByteQueue[DLL_nSPIVirtualChannelCount][DLL_nSPITXQueueByteCount]; uint8 DLL_au8ByteUARTByteQueue[DLL_nUARTVirtualChannelCount][DLL_nUARTTXQueueByteCount]; uint8 DLL_au8ByteCANByteQueue[DLL_nCANVirtualChannelCount][DLL_nCANTXQueueByteCount]; uint8 DLL_au8ByteUSBByteQueue[DLL_nUSBVirtualChannelCount][DLL_nUSBTXQueueByteCount]; uint8 DLL_au8ByteENETByteQueue[DLL_nENETVirtualChannelCount][DLL_nENETTXQueueByteCount]; /* Temp TX buff to build response and to dequeue byte-queue to for TX */ uint8 DLL_au8TXIICBuffBuild[DLL_nIICTXWorkBuffCount][DLL_nIICTXWorkBuffMaxBytes]; uint8 DLL_au8TXSPIBuffBuild[DLL_nSPITXWorkBuffCount][DLL_nSPITXWorkBuffMaxBytes]; uint8 DLL_au8TXUARTBuffBuild[DLL_nUARTTXWorkBuffCount][DLL_nUARTTXWorkBuffMaxBytes]; uint8 DLL_au8TXCANBuffBuild[DLL_nCANTXWorkBuffCount][DLL_nCANTXWorkBuffMaxBytes]; uint8 DLL_au8TXUSBBuffBuild[DLL_nUSBTXWorkBuffCount][DLL_nUSBTXWorkBuffMaxBytes]; uint8 DLL_au8TXENETBuffBuild[DLL_nENETTXWorkBuffCount][DLL_nENETTXWorkBuffMaxBytes]; /* Bytequeue struct array */ CBYTEQUEUE_tstQueue DLL_astTXDLLByteQueue[DLL_nIICVirtualChannelCount + DLL_nSPIVirtualChannelCount + DLL_nUARTVirtualChannelCount + DLL_nCANVirtualChannelCount + DLL_nUSBVirtualChannelCount + DLL_nENETVirtualChannelCount]; /* Build buffer client array */ IOAPI_tenEHIOResource DLL_aenDLLTXBufferClient[ DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount + DLL_nENETTXWorkBuffCount]; /* Transmit control structure array */ DLL_tstTXCB DLL_astTXCB[ DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nENETTXWorkBuffCount]; static void DLL_vInsertCANIDAndDLC(puint8, puint32, uint32); static IOAPI_tenEHIOResource DLL_tGetEHIOResource(DLL_tDLLVirtualChannel); static bool DLL_boSendFrame(IOAPI_tenEHIOResource, puint8, uint32); static void DLLBYTEQUEUE_vInit(CBYTEQUEUE_tstQueue*, uint32, void*); static uint32 DLLBYTEQUEUE_u32GetVacantCount(CBYTEQUEUE_tstQueue*); static uint32 DLLBYTEQUEUE_u32GetQueuedCount(CBYTEQUEUE_tstQueue*); static bool DLLBYTEQUEUE_vQueueBytes(CBYTEQUEUE_tstQueue*, puint8, uint32); static void DLLBYTEQUEUE_vDequeueBytes(CBYTEQUEUE_tstQueue*, puint8, puint32); static puint8 DLL_pu8GetTXClientBuffer(IOAPI_tenEHIOResource, puint32 pu32TXBufferCap); static void DLL_vReleaseTXClientBuffer(puint8); uint32 DLL_au32CANData[8]; DLL_tstRXDLLData* DLL_pstGetRXBuffer(IOAPI_tenEHIOResource enEHIOResource) { return &DLL_stRXDLLData[enEHIOResource - EH_VIO_IIC1]; } //void DLL_vIPBufferRXCB(ENE_tstETHUnionFrame* pstETHUnionFrame) //{ //uint8 u8ENEChannelIDX; //uint16 u16Temp; //puint8 pu8FrameData; // //IOAPI_tenEHIOResource enEHIOResource = EH_IO_Invalid; //DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(EH_VIO_ENET_CH1); // //for (u8ENEChannelIDX = 0; u8ENEChannelIDX < (EH_ENET_LAST_CH - EH_ENET_FIRST_CH + 1); u8ENEChannelIDX++) //{ //if ((EH_ENET_FIRST_CH <= //DLL_astPortConfigCB[DLLVirtualChannelIDX + u8ENEChannelIDX].enVIOResource) //&&(EH_ENET_LAST_CH >= //DLL_astPortConfigCB[DLLVirtualChannelIDX + u8ENEChannelIDX].enVIOResource)) //{ //#if (COMMS_ETH_WIFI) //if(NTOHS(DLL_astPortConfigCB[DLLVirtualChannelIDX + u8ENEChannelIDX].stNetConfig.uNetInfo.stLANNetInfo.u16RPCREQSourcePort) == //(pstETHUnionFrame -> uIPData.stUDPHeader.u16SourcePort)) //#endif //{ //if(NTOHS(DLL_astPortConfigCB[DLLVirtualChannelIDX + u8ENEChannelIDX].stNetConfig.uNetInfo.stLANNetInfo.u16RPCREQDestPort) == //(pstETHUnionFrame -> uIPData.stUDPHeader.u16DestinationPort)) //{ //enEHIOResource = (IOAPI_tenEHIOResource)(EH_VIO_ENET_CH1 + u8ENEChannelIDX); //break; //} //} //} //} // //if (EH_IO_Invalid != enEHIOResource) //{ //DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); //DLL_au16PacketSeq[DLLVirtualChannelIDX] = NTOHS(pstETHUnionFrame->uETHData.stIPHeader.u16ID); //u16Temp = NTOHS(pstETHUnionFrame->uIPData.stUDPHeader.u16UDPLength); //u16Temp = MIN(u16Temp, (uint16)RX_BUFF_SIZE); //matthew //pu8FrameData = &pstETHUnionFrame->au8UDPData[0]; // //DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = u16Temp; //memcpy((void*)&DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data, //(void*)pu8FrameData, u16Temp); // //DLL_vFrameRXCB(enEHIOResource, (puint8)&DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[0]); //} //} void DLL_vIPBufferTX(IOAPI_tenEHIOResource enEHIOResource, puint8 pu8TXData, uint32 u32TXByteCount) { } /* pu8RXData receive frame could be various frame format, hardware mailbox etc */ void DLL_vFrameRXCB(IOAPI_tenEHIOResource enEHIOResource, puint8 pu8RXData) { puint8 pu8TXData; puint8 pu8TXBuffer = NULL; uint32 u32TXByteCount = 0; uint32 u32TXByteCountOld; uint32 u32TXBufferCap; uint32 u32Temp; CANHA_tstCANMB* pstCANMB; bool boQueuedOK; DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); /* Get a response buffer */ pu8TXBuffer = DLL_pu8GetTXClientBuffer(enEHIOResource, &u32TXBufferCap); if (NULL != pu8TXBuffer) { pu8TXData = pu8TXBuffer; } else { /* No TX response buffer is available */ DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 0; return; } switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enLLUARTSZDelim: { while((nASCII_CR == *pu8RXData) || (nASCII_LF == *pu8RXData)) { pu8RXData++; } break; } default: { break; } } switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enNLProtocol) { case PROTAPI_enNLNone: { /* Invoke callback to USER NL RX handler */ if ((NULL != DLL_astPortConfigCB[DLLVirtualChannelIDX].pfRXTransferCB) && (NULL != pu8RXData)) { DLL_astPortConfigCB[DLLVirtualChannelIDX].pfRXTransferCB(enEHIOResource, pu8RXData, (uint32)(DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount), IOAPI_IO_RX); } break; } case PROTAPI_enISO15765: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enTLProtocol) { case PROTAPI_enTLUDS: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enLLCAN11: case PROTAPI_enLLCAN29: { /* Get message ID */ pstCANMB = (CANHA_tstCANMB*)pu8RXData; u32Temp = (pstCANMB -> u32ID) >> CANHA_nCANIDSTDSHIFT; //u32Temp = pstCANMB -> u32ID; /* Is the message ID for diagnostics? */ if ((DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32GlobalCANDiagAddress == u32Temp) || (DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANDiagAddress == u32Temp)) { DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[0] = (uint8)(pstCANMB -> u32DWH >> 24); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[1] = (uint8)(pstCANMB -> u32DWH >> 16); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[2] = (uint8)(pstCANMB -> u32DWH >> 8); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[3] = (uint8)(pstCANMB -> u32DWH >> 0); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[4] = (uint8)(pstCANMB -> u32DWL >> 24); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[5] = (uint8)(pstCANMB -> u32DWL >> 16); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[6] = (uint8)(pstCANMB -> u32DWL >> 8); DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[7] = (uint8)(pstCANMB -> u32DWL >> 0); DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = (uint8)((pstCANMB -> u32CS & 0x000f0000) >> 16); pu8RXData = &DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[0]; UDSNL_vReceiveFrame(enEHIOResource, pu8RXData, pu8TXData, &u32TXByteCount, u32TXBufferCap); if (0 < u32TXByteCount) { /* Insert the CANIDs and DLC */ DLL_vInsertCANIDAndDLC(pu8TXBuffer, &u32TXByteCount, DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANDiagAddress + 8); } } /* Is this a priority monitored address? */ else if (u32Temp == DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANPriorityAddress[0]) { DLL_au32CANData[0] = pstCANMB -> u32DWH; DLL_au32CANData[1] = pstCANMB -> u32DWL; } /* Is this a priority monitored address? */ else if (u32Temp == DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANPriorityAddress[1]) { DLL_au32CANData[2] = pstCANMB -> u32DWH; DLL_au32CANData[3] = pstCANMB -> u32DWL; } /* Is this a priority monitored address? */ else if (u32Temp == DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANPriorityAddress[2]) { DLL_au32CANData[4] = pstCANMB -> u32DWH; DLL_au32CANData[5] = pstCANMB -> u32DWL; } /* Is this a priority monitored address? */ else if (u32Temp == DLL_astPortConfigCB[DLLVirtualChannelIDX].stNetConfig.uNetInfo.stCANNetInfo.u32CANPriorityAddress[3]) { DLL_au32CANData[6] = pstCANMB -> u32DWH; DLL_au32CANData[7] = pstCANMB -> u32DWL; } break; } case PROTAPI_enUSB: { while (0 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount) { u32TXByteCountOld = u32TXByteCount; UDSNL_vReceiveFrame(enEHIOResource, pu8RXData, pu8TXData, &u32TXByteCount, u32TXBufferCap); DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 7 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount ? DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount - 8 : 0; pu8RXData = 0 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount ? pu8RXData + 8 : NULL; pu8TXData += (u32TXByteCount - u32TXByteCountOld); DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 0 == *pu8RXData ? 0 : DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount; } break; } default: { break; } } break; } default: { break; } } break; } case PROTAPI_enISO15765_IP: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enTLProtocol) { case PROTAPI_enTLUDS_UDP: { while (0 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount) { u32TXByteCountOld = u32TXByteCount; UDSNL_vReceiveFrame(enEHIOResource, pu8RXData, pu8TXData, &u32TXByteCount, u32TXBufferCap); DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 7 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount ? DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount - 8 : 0; pu8RXData = 0 < DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount ? pu8RXData + 8 : NULL; pu8TXData += (u32TXByteCount - u32TXByteCountOld); DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 0 == *pu8RXData ? 0 : DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount; } break; } default: { break; } } } default: { break; } } if (0 == u32TXByteCount) { /* Release the buffer if no response generated */ DLL_vReleaseTXClientBuffer(pu8TXData); } else { uint32 u32TXByteCountBoundary = u32TXByteCount; if ((u32TXByteCount % 8) != 0) { u32TXByteCountBoundary = 8 * (u32TXByteCount / 8) + 8; } /* Enqueue the response */ boQueuedOK = DLLBYTEQUEUE_vQueueBytes(&DLL_astTXDLLByteQueue[DLLVirtualChannelIDX], pu8TXBuffer, u32TXByteCountBoundary); /* Release the buffer */ DLL_vReleaseTXClientBuffer(pu8TXBuffer); } /* TODO warning suppressed */ (void)boQueuedOK; } void DLL_vStart(uint32* const u32Stat) { uint32 u32QueueIDX = 0; uint32 u32IDX; /* Initialise IIC byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nIICVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nIICTXQueueByteCount, (puint8)&DLL_au8ByteIICByteQueue[u32IDX][0]); } /* Initialise SPI byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nSPIVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nSPITXQueueByteCount, (puint8)&DLL_au8ByteSPIByteQueue[u32IDX][0]); } /* Initialise UART byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nUARTVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nUARTTXQueueByteCount, (puint8)&DLL_au8ByteUARTByteQueue[u32IDX][0]); } /* Initialise CAN byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nCANVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nCANTXQueueByteCount, (puint8)&DLL_au8ByteCANByteQueue[u32IDX][0]); } /* Initialise USB byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nUSBVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nUSBTXQueueByteCount, (puint8)&DLL_au8ByteUSBByteQueue[u32IDX][0]); } /* Initialise ENET byte queue structs */ for (u32IDX = 0; u32IDX < DLL_nENETVirtualChannelCount; u32IDX++) { DLLBYTEQUEUE_vInit(&DLL_astTXDLLByteQueue[u32QueueIDX++], DLL_nENETTXQueueByteCount, (puint8)&DLL_au8ByteENETByteQueue[u32IDX][0]); } /* Initialise the buffer client array */ for (u32IDX = 0; u32IDX < DLL_nClientTXBufferCount; u32IDX++) { DLL_aenDLLTXBufferClient[u32IDX] = EH_IO_Invalid; } /* Initialise the TX control blocks */ for (u32IDX = 0; u32IDX < (DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount + DLL_nENETTXWorkBuffCount); u32IDX++) { DLL_astTXCB[u32IDX].pu8TXData = NULL; } DLL_au32CANData[0] = ~0; DLL_au32CANData[1] = ~0; DLL_au32CANData[2] = ~0; DLL_au32CANData[3] = ~0; DLL_au32CANData[4] = ~0; DLL_au32CANData[5] = ~0; DLL_au32CANData[6] = ~0; DLL_au32CANData[7] = ~0; OS_xModuleStartOK(*u32Stat); } void DLL_vRun(uint32* const u32Stat) { DLL_tDLLVirtualChannel DLLVirtualChannelIDX; IOAPI_tenEHIOResource enEHIOResource; uint32 u32TXBytesMaxDequeued; uint32 u32TXBufferCap; puint8 pu8TXData; bool boReleaseImmediate; for (DLLVirtualChannelIDX = 0; DLLVirtualChannelIDX < DLL_nVirtualChannelCount; DLLVirtualChannelIDX++) { if (0 < DLLBYTEQUEUE_u32GetQueuedCount(&DLL_astTXDLLByteQueue[DLLVirtualChannelIDX])) { enEHIOResource = DLL_tGetEHIOResource(DLLVirtualChannelIDX); if (DLL_astPortConfigCB[DLLVirtualChannelIDX].enVIOResource == enEHIOResource) { u32TXBytesMaxDequeued = DLL_rau16TXFrameMaxBytes[DLLVirtualChannelIDX]; /* Get a TX buffer */ pu8TXData = DLL_pu8GetTXClientBuffer(enEHIOResource, &u32TXBufferCap); if (NULL != pu8TXData) { /* Uh oh really need to check if channel is available here first */ DLLBYTEQUEUE_vDequeueBytes(&DLL_astTXDLLByteQueue[DLLVirtualChannelIDX], pu8TXData, &u32TXBytesMaxDequeued); boReleaseImmediate = DLL_boSendFrame(enEHIOResource, pu8TXData, u32TXBytesMaxDequeued); if (true == boReleaseImmediate) /* Some TX channel such as ENET rebuffer so release is OK, others such as UART transit more bytes by CB, so no immediate release */ { DLL_vReleaseTXClientBuffer(pu8TXData); } } } } } } void DLL_vTerminate(uint32* const u32Stat) { } bool DLL_boInitDLLChannel(IOAPI_tenEHIOResource enEHIOResource, IOAPI_tstPortConfigCB* pstCommsConfig) { bool boRetVal = false; SYSAPI_ttClientHandle tClientHandleReq; SYSAPI_ttClientHandle tClientHandle; DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); if (-1 != DLLVirtualChannelIDX) { switch (pstCommsConfig->enVIOResource) { case EH_VIO_UART1: case EH_VIO_UART2: case EH_VIO_UART3: case EH_VIO_UART4: case EH_VIO_UART5: case EH_VIO_UART6: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stUARTPinInfo.enRXPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stUARTPinInfo.enTXPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stUARTPinInfo.enRTSPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stUARTPinInfo.enCTSPin, tClientHandleReq); break; } case EH_VIO_IIC1: case EH_VIO_IIC2: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stIICPinInfo.enSDAPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stIICPinInfo.enSCLPin, tClientHandleReq); break; } case EH_VIO_SPI1: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stSPIPinInfo.enMISOPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stSPIPinInfo.enMOSIPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stSPIPinInfo.enSCKPin, tClientHandleReq); break; } case EH_VIO_USB: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = tClientHandleReq; break; } case EH_VIO_ENET_CH1: case EH_VIO_ENET_CH2: case EH_VIO_ENET_CH3: case EH_VIO_ENET_CH4: { /* No additional pin resources are required for ENET - Kernel managed resource*/ tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = tClientHandleReq; break; } case EH_VIO_CAN1: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stCANPinInfo.enTXPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_u32RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stCANPinInfo.enRXPin, tClientHandleReq); break; } #ifdef EH_VIO_CAN2 case EH_VIO_CAN2: { tClientHandleReq = DLL_xGetClientHandle(); tClientHandle = (SYSAPI_ttClientHandle)RESM_RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stCANPinInfo.enTXPin, tClientHandleReq); tClientHandle &= (SYSAPI_ttClientHandle)RESM_RequestEHIOResource(pstCommsConfig->stPinConfig.uPinInfo.stCANPinInfo.enRXPin, tClientHandleReq); break; } #endif //EH_VIO_CAN2 default: { tClientHandleReq = 0xffffffff; tClientHandle = 0; break; } } if (tClientHandleReq == tClientHandle) { memcpy(&DLL_astPortConfigCB[DLLVirtualChannelIDX], pstCommsConfig, sizeof(IOAPI_tstPortConfigCB)); boRetVal = true; } } return boRetVal; } void DLL_vReceiveUARTBytes(IOAPI_tenEHIOResource enEHIOResource, DLL_tstRXDLLData* pRXFrame) { DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); DLL_stRXDLLData[DLLVirtualChannelIDX].biRXFull = false; while(pRXFrame->u8DataCount-- > 0) { switch(DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enLLUARTPacked: if((0x80 & pRXFrame->u8Data[0]) == 0x80) { if((0xC0 & pRXFrame->u8Data[0]) == 0xC0) { DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX = 0; } else { if(DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX == (TXRX_MSB_DELIM_SIZE - 1)) DLL_stRXDLLData[DLLVirtualChannelIDX].biRXFull = true; } } DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[ DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX++] = pRXFrame->u8Data[pRXFrame->u8RXByteIDX++]; break; case PROTAPI_enLLUARTSZDelim: if((NULL != pRXFrame -> u8Data[0]) && (nASCII_LF != pRXFrame -> u8Data[0])) { DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount++; DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[ DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX++] = pRXFrame->u8Data[pRXFrame->u8RXByteIDX]; if(nASCII_CR == pRXFrame -> u8Data[0]) { DLL_stRXDLLData[DLLVirtualChannelIDX].biRXFull = true; } } break; default: break; } } if(DLL_stRXDLLData[DLLVirtualChannelIDX].biRXFull == true) { if(PROTAPI_enLLUARTPacked == DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { PACKEDDLL_vUnpack(&DLL_stRXDLLData[DLLVirtualChannelIDX]); } if(PROTAPI_enLLUARTSZDelim == DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX] = 0; DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount++; } DLL_stRXDLLData[DLLVirtualChannelIDX].u8RXByteIDX = 0; DLL_stRXDLLData[DLLVirtualChannelIDX].u8DataCount = 8; pRXFrame->biRXFull = false; DLL_vFrameRXCB(enEHIOResource, &DLL_stRXDLLData[DLLVirtualChannelIDX].u8Data[0]); } } void DLL_vTransmitUARTBytesCB(IOAPI_tenEHIOResource enEHIOResource) { DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); if (NULL != DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData) { if (0 < DLL_astTXCB[DLLVirtualChannelIDX].u8ByteCount) { DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData++; DLL_astTXCB[DLLVirtualChannelIDX].u8ByteCount--; UART_vSendChar(enEHIOResource, *DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData); } else { UART_vDisableTXInterrupt(enEHIOResource); DLL_vReleaseTXClientBuffer(DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData); DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData = NULL; } } } static bool DLL_boSendFrame(IOAPI_tenEHIOResource enEHIOResource, puint8 pu8TXData, uint32 u32TXByteCount) { DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); IOAPI_tstTransferCB stTransferCB; PROTAPI_tstCANMsg stCANMsg; bool boSyncSent = false; switch(enEHIOResource) { case EH_VIO_UART1: case EH_VIO_UART2: case EH_VIO_UART3: case EH_VIO_UART4: case EH_VIO_UART5: case EH_VIO_UART6: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enLLUARTPacked: { if (9 > u32TXByteCount) { /* TODO */ } break; } case PROTAPI_enLLUARTSZDelim: { u32TXByteCount = DLL_nTXBytesBufferSize >= u32TXByteCount ? u32TXByteCount : DLL_nTXBytesBufferSize; if (NULL == DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData) { DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData = pu8TXData; DLL_astTXCB[DLLVirtualChannelIDX].u8ByteCount = u32TXByteCount; UART_vSendChar(enEHIOResource, *(DLL_astTXCB[DLLVirtualChannelIDX].pu8TXData)); } break; } default: { break; } } break; } case EH_VIO_ENET_CH1: case EH_VIO_ENET_CH2: case EH_VIO_ENET_CH3: case EH_VIO_ENET_CH4: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enLL802_3: { DLL_vIPBufferTX(enEHIOResource, pu8TXData, u32TXByteCount); boSyncSent = true; break; } default: { break; } } break; } case EH_VIO_CAN1: #ifdef EH_VIO_CAN2 case EH_VIO_CAN2: #endif { stCANMsg.u32ID = ((*(pu8TXData) & 0x1f) << 24) + (*(pu8TXData + 1) << 16) + (*(pu8TXData + 2) << 8) + (*(pu8TXData + 3) << 0); stCANMsg.u32DWH = (*(pu8TXData + 4) << 24) + (*(pu8TXData + 5) << 16) + (*(pu8TXData + 6) << 8) + (*(pu8TXData + 7) << 0); stCANMsg.u32DWL = (*(pu8TXData + 8) << 24) + (*(pu8TXData + 9) << 16) + (*(pu8TXData + 10) << 8) + (*(pu8TXData + 11) << 0); stCANMsg.u8DLC = ((*pu8TXData) >> 5) + 1; stTransferCB.enEHIOResource = enEHIOResource; stTransferCB.enTransferType = IOAPI_IO_TX; stTransferCB.pfCB = NULL; stTransferCB.pvData = (void*)&stCANMsg; stTransferCB.u32ByteCount = u32TXByteCount; CAN_vInitTransfer(&stTransferCB); boSyncSent = true; break; } case EH_VIO_USB: { switch (DLL_astPortConfigCB[DLLVirtualChannelIDX].enLLProtocol) { case PROTAPI_enUSB: { VCOMHA_vSend(enEHIOResource, pu8TXData, u32TXByteCount); boSyncSent = true; break; } default: { break; } } } default: { break; } } return boSyncSent; } bool DLL_vQueueCANMessage(IOAPI_tenEHIOResource enEHIOResource, PROTAPI_tstCANMsg* pstCANMsg) { bool boRetVal; uint8 au8TXData[12]; uint32 u32TXByteCount = 12;//pstCANMsg->u8DLC + 4; au8TXData[0] = (pstCANMsg->u8DLC - 1) << 5; au8TXData[0] += ((pstCANMsg->u32ID & 0x1f000000) >> 24); au8TXData[1] = (pstCANMsg->u32ID >> 16) & 0xff; au8TXData[2] = (pstCANMsg->u32ID >> 8) & 0xff; au8TXData[3] = pstCANMsg->u32ID & 0xff; au8TXData[4] = (pstCANMsg->u32DWH >> 24) & 0xff; au8TXData[5] = (pstCANMsg->u32DWH >> 16) & 0xff; au8TXData[6] = (pstCANMsg->u32DWH >> 8) & 0xff; au8TXData[7] = pstCANMsg->u32DWH & 0xff; au8TXData[8] = (pstCANMsg->u32DWL >> 24) & 0xff; au8TXData[9] = (pstCANMsg->u32DWL >> 16) & 0xff; au8TXData[10] = (pstCANMsg->u32DWL >> 8) & 0xff; au8TXData[11] = pstCANMsg->u32DWL & 0xff; boRetVal = DLL_boQueueMessage(enEHIOResource, &au8TXData[0], u32TXByteCount); return boRetVal; } bool DLL_boQueueMessage(IOAPI_tenEHIOResource enEHIOResource, puint8 pu8TXBuffer, uint32 u32TXByteCount) { DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); bool boQueueOK = false; if (0 <= DLLVirtualChannelIDX) { boQueueOK = DLLBYTEQUEUE_vQueueBytes(&DLL_astTXDLLByteQueue[DLLVirtualChannelIDX], pu8TXBuffer, u32TXByteCount); } return boQueueOK; } DLL_tDLLVirtualChannel DLL_tGetVirtualChannel(IOAPI_tenEHIOResource enEHIOResource) { DLL_tDLLVirtualChannel DLLVirtualChannel = -1; if ((EH_VIO_IIC1 <= enEHIOResource) && (EH_VIO_ENET_CH4 >= enEHIOResource)) { DLLVirtualChannel = enEHIOResource - EH_VIO_IIC1; } return DLLVirtualChannel; } static IOAPI_tenEHIOResource DLL_tGetEHIOResource(DLL_tDLLVirtualChannel DLLVirtualChannel) { return (IOAPI_tenEHIOResource)(EH_VIO_IIC1 + DLLVirtualChannel); } IOAPI_tenPortMode DLL_enGetChannelMode(IOAPI_tenEHIOResource enEHIOResource) { IOAPI_tenPortMode enMode = IOAPI_enPortNone; DLL_tDLLVirtualChannel DLLVirtualChannelIDX = DLL_tGetVirtualChannel(enEHIOResource); if (-1 != DLLVirtualChannelIDX) { enMode = DLL_astPortConfigCB[DLLVirtualChannelIDX].enPortMode; } return enMode; } static void DLLBYTEQUEUE_vInit(CBYTEQUEUE_tstQueue* pstQueue, uint32 u32Size, void* pu8Data) { pstQueue->u32Head = 0; pstQueue->u32Tail = 0; pstQueue->u32Size = u32Size; pstQueue->pu8Data = pu8Data; } static uint32 DLLBYTEQUEUE_u32GetVacantCount(CBYTEQUEUE_tstQueue* pstQueue) { uint32 u32VacantCount; if (pstQueue->u32Head <= pstQueue->u32Tail) { u32VacantCount = pstQueue->u32Size - (pstQueue->u32Tail - pstQueue->u32Head) - 1; } else { u32VacantCount = pstQueue->u32Head - pstQueue->u32Tail - 1; } return u32VacantCount; } static uint32 DLLBYTEQUEUE_u32GetQueuedCount(CBYTEQUEUE_tstQueue* pstQueue) { return (pstQueue->u32Size - DLLBYTEQUEUE_u32GetVacantCount(pstQueue) - 1); } static bool DLLBYTEQUEUE_vQueueBytes(CBYTEQUEUE_tstQueue* pstQueue, puint8 pu8TXData, uint32 u32TXByteCount) { bool boRetVal = FALSE; uint32 u32Temp; if (u32TXByteCount <= DLLBYTEQUEUE_u32GetVacantCount(pstQueue)) { if (pstQueue->u32Head <= pstQueue->u32Tail) { u32Temp = pstQueue->u32Size - pstQueue->u32Tail; memcpy(pstQueue->pu8Data + pstQueue->u32Tail, pu8TXData, MIN(u32Temp, u32TXByteCount)); if (u32Temp < u32TXByteCount) { memcpy(pstQueue->pu8Data, pu8TXData + u32Temp, u32TXByteCount - u32Temp); } } else { memcpy(pstQueue->pu8Data + pstQueue->u32Tail, pu8TXData, u32TXByteCount); } boRetVal = TRUE; pstQueue->u32Tail = (pstQueue->u32Tail + u32TXByteCount) % pstQueue->u32Size; } return boRetVal; } static void DLLBYTEQUEUE_vDequeueBytes(CBYTEQUEUE_tstQueue* pstQueue, puint8 pu8Data, puint32 pu32ByteCount) { uint32 u32Temp; uint32 u32BytesQueued = DLLBYTEQUEUE_u32GetQueuedCount(pstQueue); *pu32ByteCount = MIN(*pu32ByteCount , u32BytesQueued); if (pstQueue->u32Head < pstQueue->u32Tail) { memcpy(pu8Data, pstQueue->pu8Data + pstQueue->u32Head, *pu32ByteCount); } else { u32Temp = pstQueue->u32Size - pstQueue->u32Head; u32Temp = MIN(*pu32ByteCount, u32Temp); memcpy(pu8Data, pstQueue->pu8Data + pstQueue->u32Head, u32Temp); if (*pu32ByteCount > u32Temp) { memcpy(pu8Data + u32Temp, pstQueue->pu8Data, *pu32ByteCount - u32Temp); } } pstQueue->u32Head = (pstQueue->u32Head + *pu32ByteCount) % pstQueue->u32Size; } static puint8 DLL_pu8GetTXClientBuffer(IOAPI_tenEHIOResource enEHIOResource, puint32 pu32TXBufferCap) { uint8 u8BufferIDXStart; uint8 u8BufferIDXEnd; uint8 u8BufferIDX; puint8 pu8Buffer; uint32 u32BufferBytes; bool boVacantBuff = false; switch (enEHIOResource) { case EH_VIO_IIC1: case EH_VIO_IIC2: { u8BufferIDXStart = 0; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount; pu8Buffer = &DLL_au8TXIICBuffBuild[0][0]; u32BufferBytes = DLL_nIICTXWorkBuffMaxBytes; break; } case EH_VIO_SPI1: case EH_VIO_SPI2: { u8BufferIDXStart = DLL_nIICTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount; pu8Buffer = &DLL_au8TXSPIBuffBuild[0][0]; u32BufferBytes = DLL_nSPITXWorkBuffMaxBytes; break; } case EH_VIO_UART1: case EH_VIO_UART2: case EH_VIO_UART3: case EH_VIO_UART4: case EH_VIO_UART5: case EH_VIO_UART6: { u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount; pu8Buffer = &DLL_au8TXUARTBuffBuild[0][0]; u32BufferBytes = DLL_nUARTTXWorkBuffMaxBytes; break; } case EH_VIO_CAN1: { u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount; pu8Buffer = &DLL_au8TXCANBuffBuild[0][0]; u32BufferBytes = DLL_nCANTXWorkBuffMaxBytes; break; } case EH_VIO_USB: { u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount; pu8Buffer = &DLL_au8TXUSBBuffBuild[0][0]; u32BufferBytes = DLL_nUSBTXWorkBuffMaxBytes; break; } case EH_VIO_ENET_CH1: case EH_VIO_ENET_CH2: case EH_VIO_ENET_CH3: case EH_VIO_ENET_CH4: { u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount + DLL_nENETTXWorkBuffCount; pu8Buffer = &DLL_au8TXENETBuffBuild[0][0]; u32BufferBytes = DLL_nENETTXWorkBuffMaxBytes; break; } default: { u8BufferIDXStart = 0; u8BufferIDXStart = 0; break; } } for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if(EH_IO_Invalid == DLL_aenDLLTXBufferClient[u8BufferIDX]) { DLL_aenDLLTXBufferClient[u8BufferIDX] = enEHIOResource; boVacantBuff = true; break; } pu8Buffer += u32BufferBytes; } pu8Buffer = (true == boVacantBuff) ? pu8Buffer : NULL; *pu32TXBufferCap = u32BufferBytes; return pu8Buffer; } static void DLL_vInsertCANIDAndDLC(puint8 pu8TXBuffer, puint32 pu32TXByteCount, uint32 u32CANID) { uint32 u32TXByteCount = *pu32TXByteCount; uint32 u32TXByteCountNew = 0; uint32 u32FrameCount = u32TXByteCount / 8; uint32 u32FrameBytes; puint8 pu8Dest; puint8 pu8Source; if (0 != (u32TXByteCount % 8)) { u32FrameCount++; } while (0 < u32FrameCount--) { pu8Dest = pu8TXBuffer + (12 * u32FrameCount) + 4; pu8Source = pu8TXBuffer + (8 * u32FrameCount); if (0 != (u32TXByteCount % 8)) { u32FrameBytes = u32TXByteCount % 8; u32TXByteCount -= (u32TXByteCount % 8); } else { u32FrameBytes = 8; u32TXByteCount -= 8; } u32TXByteCountNew += u32FrameBytes; u32TXByteCountNew += 4; while (0 < u32FrameBytes) { u32FrameBytes--; *(pu8Dest + u32FrameBytes) = *(pu8Source + u32FrameBytes); } pu8Dest -= 4; *pu8Dest++ = (((u32FrameBytes - 1) & 0xff) << 5) + ((u32CANID & 0x1f000000) >> 24); *pu8Dest++ = (u32CANID & 0xff0000) >> 16; *pu8Dest++ = (u32CANID & 0xff00) >> 8; *pu8Dest = (u32CANID & 0xff); } *pu32TXByteCount = u32TXByteCountNew; } static void DLL_vReleaseTXClientBuffer(puint8 pu8TXBuffer) { uint8 u8BufferIDXStart; uint8 u8BufferIDXEnd; uint8 u8BufferIDX; puint8 pu8Buffer; uint32 u32BufferBytes; bool boBufferReleased = false; /* Try release a IIC client working buffer */ u8BufferIDXStart = 0; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount; pu8Buffer = &DLL_au8TXIICBuffBuild[0][0]; u32BufferBytes = DLL_nIICTXWorkBuffMaxBytes; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } if (true == boBufferReleased) return; /* Try release a SPI client working buffer */ u8BufferIDXStart = DLL_nIICTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount; pu8Buffer = &DLL_au8TXSPIBuffBuild[0][0]; u32BufferBytes = DLL_nSPITXWorkBuffMaxBytes; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } if (true == boBufferReleased) return; /* Try release a UART client working buffer */ u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount; pu8Buffer = &DLL_au8TXUARTBuffBuild[0][0]; u32BufferBytes = DLL_nUARTTXWorkBuffMaxBytes; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } if (true == boBufferReleased) return; /* Try release an IIC client working buffer */ u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount; pu8Buffer = &DLL_au8TXCANBuffBuild[0][0]; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } if (true == boBufferReleased) return; /* Try release a USB client working buffer */ u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nENETTXWorkBuffCount; pu8Buffer = &DLL_au8TXUSBBuffBuild[0][0]; u32BufferBytes = DLL_nUSBTXWorkBuffMaxBytes; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } if (true == boBufferReleased) return; /* Try release a ENET client working buffer */ u8BufferIDXStart = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount; u8BufferIDXEnd = DLL_nIICTXWorkBuffCount + DLL_nSPITXWorkBuffCount + DLL_nUARTTXWorkBuffCount + DLL_nCANTXWorkBuffCount + DLL_nUSBTXWorkBuffCount + DLL_nENETTXWorkBuffCount; pu8Buffer = &DLL_au8TXENETBuffBuild[0][0]; u32BufferBytes = DLL_nENETTXWorkBuffMaxBytes; for (u8BufferIDX = u8BufferIDXStart; u8BufferIDX < u8BufferIDXEnd; u8BufferIDX++) { if ((pu8Buffer <= pu8TXBuffer) && ((pu8Buffer + u32BufferBytes) > pu8TXBuffer)) { DLL_aenDLLTXBufferClient[u8BufferIDX] = EH_IO_Invalid; boBufferReleased = true; } pu8Buffer += u32BufferBytes; } } void* DLL_pvGetBuffered(IOAPI_tenEHIOResource enEHIOResource) { void* pvData = NULL; switch (enEHIOResource) { case EH_VIO_CAN1: { pvData = (void*)&DLL_au32CANData; break; } default: { break; } } return pvData; }