diff options
Diffstat (limited to 'lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c')
| -rw-r--r-- | lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c | 674 |
1 files changed, 269 insertions, 405 deletions
diff --git a/lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c b/lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c index bbdc4b0..2fab495 100644 --- a/lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c +++ b/lcmodule/source/cnh1605204_ldr_transport_layer/source/bulk_protocol.c @@ -30,7 +30,6 @@ #include "r_communication_service.h" #include "t_security_algorithms.h" #include "r_memory_utils.h" -#include "r_critical_section.h" #ifdef CFG_ENABLE_MEASUREMENT_TOOL #include "r_measurement_tool.h" @@ -40,41 +39,54 @@ /*********************************************************************** * Definition of external constants and variables **********************************************************************/ +#define SESSION(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.Session +#define CHUNKSIZE(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.ChunkSize +#define LENGTH(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.Length +#define OFFSET(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.Offset +#define TOTALLENGTH(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.BulkHandle.BulkVector_p->TotalLength +#define TRANSFEREDLENGTH(x) ((R15_FamilyContext_t *)(x)->FamilyContext_p)->Transport.BulkHandle.BulkVector_p->TransferedLength + #ifdef CFG_ENABLE_MEASUREMENT_TOOL extern Measurement_t *Measurement_p; #endif +typedef struct { + TL_BulkVectorList_t *BulkVector_p; + uint32 ChunkId; + uint8 *ChunksList_p; +} TL_RetransmissionRequest_t; + +static TL_RetransmissionRequest_t RetransmissionRequest; + static void R15_Bulk_ReadChunkCallBack(Communication_t *Communication_p, const void *const Timer_p, const void *const Data_p); +static void R15_Bulk_ReadDataChunkCallBack(Communication_t *Communication_p, const void *const Timer_p, const void *const Data_p); static void R15_Bulk_RetransmitChunks_CallBack(const Communication_t *const Communication_p, const void *const Timer_p, const void *const Data_p); static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_BulkVectorList_t *BulkVector_p, PacketMeta_t *Packet_p); static ErrorCode_e R15_Bulk_SendReadRequest(Communication_t *Communication_p, TL_BulkVectorList_t *BulkVector_p, uint32 Chunks, void *ChunksList_p, void *CallBack_p); static ErrorCode_e R15_Bulk_SendWriteRequest(Communication_t *Communication_p); -static void R15_Bulk_SerializeChunk(Communication_t *Communication_p, PacketMeta_t *Packet_p, uint32 ChunkId); -static void R15_Bulk_SendData(Communication_t *Communication_p, PacketMeta_t *Packet_p); +static void R15_Bulk_SendData(Communication_t *Communication_p, PacketMeta_t *Packet_p, uint32 ChunkId); static boolean R15_Bulk_CheckTransmitedChunks(const TL_BulkVectorList_t *BulkVector_p); static boolean R15_Bulk_CheckIdInList(const TL_BulkVectorList_t *BulkVector_p, const uint32 ChunkId, const uint8 *const Data_p, const uint32 Length); -static uint32 R15_Bulk_GetChunkForSending(const TL_BulkVectorList_t *BulkVector_p); -static uint32 R15_Bulk_GetChunkForSeriazliation(const TL_BulkVectorList_t *BulkVector_p); +static uint32 R15_Bulk_GetNextPacketChunkId(const TL_BulkVectorList_t *BulkVector_p); static void R15_Bulk_GetListOfReceivedChunks(const TL_BulkVectorList_t *const BulkVector_p, uint32 *Chunks_p, uint8 *ChunkList_p); static uint32 R15_Bulk_GetChunkId(const PacketMeta_t *const Packet_p); static uint32 R15_Bulk_GetTimerChunkRetransmision(const Communication_t *const Communication_p, uint32 Time, HandleFunction_t CallBack_p); static void R15_Bulk_MarkNotAckChunks(TL_BulkVectorList_t *BulkVector_p, const uint8 *const Payload_p, const uint32 Length); static void R15_Bulk_MarkNotAckAllChunks(TL_BulkVectorList_t *BulkVector_p); +#ifdef CFG_ENABLE_LOADER_TYPE +static boolean R15_Bulk_CheckAcknowledgedChunks(const TL_BulkVectorList_t *BulkVector_p, const uint8 *const Payload_p); +#endif static void R15_Bulk_OutHashCallback(const void *const Data_p, uint32 Length, const uint8 *const Hash_p, void *Param_p); static TL_BulkVectorStatus_t R15_Bulk_GetVectorStatus(TL_BulkVectorList_t *BulkVector_p); -static boolean R15_Bulk_VectorNeedsRetransmission(TL_BulkVectorList_t *BulkVector_p, uint32 CurrentChunkId); -static void R15_Bulk_VectorClearRetransmissionRequested(TL_BulkVectorList_t *BulkVector_p); static TL_BulkSessionID_Status_t R15_Bulk_CheckBulkSession(Communication_t *Communication_p, uint16 SessionId); static ErrorCode_e R15_Bulk_DataRequestHandler(Communication_t *Communication_p, PacketMeta_t *Packet_p); static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, PacketMeta_t *Packet_p); -static boolean R15_Bulk_AllChunksProcessed(const TL_BulkVectorList_t *const BulkVector_p); -#ifdef CFG_ENABLE_LOADER_TYPE -static boolean R15_Bulk_CheckAcknowledgedChunks(const TL_BulkVectorList_t *BulkVector_p, const uint8 *const Payload_p); -#else -static boolean R15_Bulk_SessionTxDone(const TL_BulkVectorList_t *const BulkVector_p); +#ifndef CFG_ENABLE_LOADER_TYPE +static void R15_Bulk_ClearBulkTmpParam(Communication_t *Communication_p); static boolean IsChunkReceived(Communication_t *Communication_p, uint32 ChunkId); -#endif // CFG_ENABLE_LOADER_TYPE +#endif + /*********************************************************************** * Definition of external functions @@ -185,7 +197,6 @@ TL_BulkVectorList_t *Do_R15_Bulk_CreateVector(const Communication_t *const Commu for (Counter = 0; (Counter < Buffers); Counter++) { BulkVector_p->Entries[Counter].Buffer_p = NULL; - BulkVector_p->Entries[Counter].RetransmissionRequested = FALSE; if (BULK_SEND == BulkVector_p->Mode) { #ifdef CFG_ENABLE_LOADER_TYPE @@ -253,8 +264,8 @@ TL_BulkVectorList_t *Do_R15_Bulk_CreateVector(const Communication_t *const Commu * * @param [in] Communication_p Communication module context. * @param [in] BulkVector_p Pointer to the Bulk Vector. - * @param [in] ReqReleaseBuffer Defines if complete buffers with meta data will - * be released or only only the meta data will be cleared. + * @param [in] ReqReleaseBuffer Defines if complete buffers with metadata will + * be released or only only the metadata will be cleared. * * @retval E_SUCCESS After successful execution. * @retval BULK_ERROR Error while destroying vector. @@ -278,7 +289,6 @@ uint32 Do_R15_Bulk_DestroyVector(const Communication_t *const Communication_p, T /* clear all flags by setting buffer as free */ BulkVector_p->Entries[Counter].Buffer_p->Flags = BUF_FREE; BulkVector_p->Entries[Counter].Hash_p = NULL; - BulkVector_p->Entries[Counter].RetransmissionRequested = FALSE; if (NULL != BulkVector_p->Entries[Counter].Buffer_p) { if (ReqReleaseBuffer) { @@ -337,9 +347,9 @@ ErrorCode_e Do_R15_Bulk_StartSession(Communication_t *Communication_p, TL_BulkVe /* Verify the new bulk vector. */ VERIFY(NULL != BulkVector_p, E_INVALID_INPUT_PARAMETERS); - /* Verify that the bulk session is opened for this bulk vector. */ + /* Verify that the bulk session is opend for this bulk vector. */ VERIFY(BULK_SESSION_IDLE != BulkVector_p->Status, E_FAILED_TO_START_BULK_SESSION); - /* Verify that the previous bulk session is closed. */ + /* Verify that the previouse bulk session is closed. */ VERIFY(NULL == R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p, E_PREVIOUS_BULK_SESSION_IS_NOT_CLOSED); BulkVector_p->Status = BULK_SESSION_PROCESSING; @@ -385,6 +395,7 @@ ErrorExit: return ReturnValue; } + /* * Get status of bulk transfer. * @@ -436,6 +447,7 @@ ErrorExit: return ReturnValue; } + /* * Handling received bulk command. * @@ -467,7 +479,7 @@ ErrorCode_e R15_Bulk_Process(Communication_t *Communication_p, PacketMeta_t *Pac #ifdef CFG_ENABLE_LOADER_TYPE if ((NULL == BulkVector_p) || (ExtendedHeader.Session != BulkVector_p->SessionId)) { - C_(printf("bulk_protocol.c (%d): Session is not opened(%d) or wrong session(%d)! \n", __LINE__, R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p, ExtendedHeader.Session);) + C_(printf("bulk_protocol.c (%d): Session is not opend(%d) or wrong session(%d)! \n", __LINE__, R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p, ExtendedHeader.Session);) if ((CMD_BULK_DATA == (ExtendedHeader.TypeFlags & MASK_BULK_COMMAND_SELECT)) && NULL != PreviousBulkVector_p) { @@ -497,8 +509,14 @@ ErrorCode_e R15_Bulk_Process(Communication_t *Communication_p, PacketMeta_t *Pac case CMD_BULK_WRITE: if (NULL != R15_TRANSPORT(Communication_p)->BulkCommandCallback_p) { - BulkCommandReqCallback_t pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, ExtendedHeader.Session, ExtendedHeader.ChunkSize, ExtendedHeader.Offset, ExtendedHeader.Length, FALSE); + BulkCommandReqCallback_t pcbf; + SESSION(Communication_p) = ExtendedHeader.Session; + CHUNKSIZE(Communication_p) = ExtendedHeader.ChunkSize; + OFFSET(Communication_p) = ExtendedHeader.Offset; + LENGTH(Communication_p) = ExtendedHeader.Length; + pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), FALSE); + R15_Bulk_ClearBulkTmpParam(Communication_p); } /* release the buffer for undefined command */ @@ -523,6 +541,7 @@ ErrorExit: return ReturnValue; } + #ifdef CFG_ENABLE_LOADER_TYPE /* * Generate bulk Session ID. Allowed bulk session ID is from 1 to 65535. @@ -550,47 +569,21 @@ uint16 Do_R15_Bulk_GenerateBulkSessionID(Communication_t *Communication_p) /*********************************************************************** * Definition of internal functions **********************************************************************/ -/* - * Get the Chunk ID for the next bulk packet which is ready for transmitting. - * - * @param [in] BulkVector_p Current bulk vector used for bulk transfer. - * - * @retval ChunkID Chunk ID for the next ready for transmitting packet. - * If none chunk is ready return last Chunk ID + 1. - */ -static uint32 R15_Bulk_GetChunkForSending(const TL_BulkVectorList_t *BulkVector_p) -{ - uint32 ChunkId = 0; - - for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - if (CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_READY) && - CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_PAYLOAD_CRC_CALCULATED)) { - break; - } - } - - return ChunkId; -} /* - * Get the Chunk ID for the next bulk packet which is ready for serialization. - * - * Packet should be properly allocated, ready for sending and it should not be - * in process of CRC Calculation or CRC has not been yet calculated. + * Get the Chunk ID for the next bulk packet which is ready for transmitting. * * @param [in] BulkVector_p Current bulk vector used for bulk transfer. * * @retval ChunkID Chunk ID for the next ready for transmitting packet. * If none chunk is ready return last Chunk ID + 1. */ -static uint32 R15_Bulk_GetChunkForSeriazliation(const TL_BulkVectorList_t *BulkVector_p) +static uint32 R15_Bulk_GetNextPacketChunkId(const TL_BulkVectorList_t *BulkVector_p) { uint32 ChunkId = 0; for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - if ((CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, (BUF_ALLOCATED | BUF_TX_READY))) && - !(CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_CRC_CALCULATING)) && - !(CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_PAYLOAD_CRC_CALCULATED))) { + if (CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_READY)) { break; } } @@ -599,7 +592,7 @@ static uint32 R15_Bulk_GetChunkForSeriazliation(const TL_BulkVectorList_t *BulkV } /* - * Check all created chunks is it transmitted. + * Check all created chunks is it transmited. * * @param [in] BulkVector_p Current bulk vector used for bulk transfer. * @param [in] ChunkId ChunkID for the packet which need to be transmitted. @@ -633,9 +626,9 @@ static boolean R15_Bulk_CheckTransmitedChunks(const TL_BulkVectorList_t *BulkVec static boolean R15_Bulk_CheckAcknowledgedChunks(const TL_BulkVectorList_t *BulkVector_p, const uint8 *const Payload_p) { uint32 i; - uint8 Data[MAX_BULK_TL_PROCESSES]; + uint8 Data[16]; - memset(Data, 0, MAX_BULK_TL_PROCESSES); + memset(Data, 0, 16); for (i = 0; i < BulkVector_p->Buffers; i++) { Data[i] = (uint8)i; @@ -654,13 +647,10 @@ static void R15_Bulk_MarkNotAckChunks(TL_BulkVectorList_t *BulkVector_p, const u uint32 ChunkId; for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - if (R15_Bulk_CheckIdInList(BulkVector_p, ChunkId, Payload_p, Length)) { - /* Packet acknowledged. Set TX state DONE */ - SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_DONE); - } else if (!CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_SENDING)) { - /* Packet needs retransmission. Set it ready for transmitting. */ + if (!R15_Bulk_CheckIdInList(BulkVector_p, ChunkId, Payload_p, Length) && + !CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_SENDING)) { SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_READY); - BulkVector_p->State = PROCESSING_CHUNKS; + BulkVector_p->State = SENDING_CHUNKS; } } } @@ -670,13 +660,10 @@ static void R15_Bulk_MarkNotAckAllChunks(TL_BulkVectorList_t *BulkVector_p) uint32 ChunkId; for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - /* Check if buffer is in process of sending in order to avoid marking it - for sending again. */ - if (!CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_SENDING)) { - SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_READY); - BulkVector_p->State = PROCESSING_CHUNKS; - } + SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_READY); } + + BulkVector_p->State = SENDING_CHUNKS; } static boolean R15_Bulk_CheckIdInList(const TL_BulkVectorList_t *BulkVector_p, const uint32 ChunkId, const uint8 *const Data_p, const uint32 Length) @@ -695,7 +682,7 @@ static boolean R15_Bulk_CheckIdInList(const TL_BulkVectorList_t *BulkVector_p, c static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_BulkVectorList_t *BulkVector_p, PacketMeta_t *Packet_p) { uint32 ChunkId = 0; - uint8 ChunksList[MAX_BULK_TL_PROCESSES] = {0}; + uint8 ChunksList[MAX_BULK_TL_PROCESSES]; ErrorCode_e ReturnValue = E_SUCCESS; TL_BulkVectorStatus_t ChunkReceivedStatus; #ifndef CFG_ENABLE_LOADER_TYPE @@ -772,7 +759,6 @@ static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_Bu if (VECTOR_COMPLETE == ChunkReceivedStatus) { C_(printf("bulk_protocol.c(%d) Last Chunk Received (%d)\n", __LINE__, ChunkId);) - R15_Bulk_VectorClearRetransmissionRequested(BulkVector_p); /* save the current bulk vector before is bulk session closed */ memcpy(&(R15_TRANSPORT(Communication_p))->PreviousBulkVector, BulkVector_p, sizeof(TL_BulkVectorList_t)); ReturnValue = R15_Bulk_SendReadRequest(Communication_p, BulkVector_p, ChunkId, ChunksList, NULL); @@ -781,21 +767,16 @@ static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_Bu #ifndef CFG_ENABLE_LOADER_TYPE // notify session end pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, TRUE); + pcbf(Communication_p->Object_p, &BulkVector_p->SessionId, &BulkVector_p->ChunkSize, &BulkVector_p->Offset, &BulkVector_p->Length, TRUE); #endif } else if (VECTOR_MISSING_CHUNK == ChunkReceivedStatus) { - uint32 CurrentChunkId = R15_Bulk_GetChunkId(Packet_p); - boolean RetransmissionNeeded = R15_Bulk_VectorNeedsRetransmission(BulkVector_p, CurrentChunkId); - if (RetransmissionNeeded) { - // Send ReadRequest for the missing chunk(s). - ReturnValue = R15_Bulk_SendReadRequest(Communication_p, BulkVector_p, ChunkId, ChunksList, NULL); - } else { - // ReadRequest was previously send for the missing chunk(s). - R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = R15_Bulk_GetTimerChunkRetransmision(Communication_p, R15_TIMEOUTS(Communication_p)->TBDR, (HandleFunction_t)R15_Bulk_ReadChunkCallBack); - } + ReturnValue = R15_Bulk_SendReadRequest(Communication_p, BulkVector_p, ChunkId, ChunksList, NULL); } else { // Chunks are received in order - R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = R15_Bulk_GetTimerChunkRetransmision(Communication_p, R15_TIMEOUTS(Communication_p)->TBDR, (HandleFunction_t)R15_Bulk_ReadChunkCallBack); + RetransmissionRequest.BulkVector_p = BulkVector_p; + RetransmissionRequest.ChunkId = ChunkId; + RetransmissionRequest.ChunksList_p = ChunksList; + R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = R15_Bulk_GetTimerChunkRetransmision(Communication_p, R15_TIMEOUTS(Communication_p)->TBDR, (HandleFunction_t)R15_Bulk_ReadDataChunkCallBack); } break; @@ -809,6 +790,7 @@ static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_Bu return ReturnValue; } + /* * State machine for bulk transfer from ME to PC. * @@ -819,161 +801,103 @@ static ErrorCode_e R15_Bulk_Process_Read(Communication_t *Communication_p, TL_Bu ErrorCode_e R15_Bulk_Process_Write(Communication_t *Communication_p, TL_BulkVectorList_t *BulkVector_p) { ErrorCode_e ReturnValue = E_SUCCESS; - uint32 ProcessingChunkId; + uint32 ChunkId; + static uint32 reentrant = 1; - if (!Do_CriticalSection_Enter(R15_TRANSPORT(Communication_p)->BulkHandle.BulkTransferCS)) { - return ReturnValue; - } + if (reentrant) { + reentrant = 0; - if (BulkVector_p->Mode == BULK_SEND) { - switch (BulkVector_p->State) { - /* Idle state */ - case BULK_IDLE_STATE: - // wait to start the bulk session - break; + if (BulkVector_p->Mode == BULK_SEND) { + switch (BulkVector_p->State) { + /* Idle state */ + case BULK_IDLE_STATE: + // wait to start the bulk session + break; - case SEND_WRITE_REQUEST: - ReturnValue = R15_Bulk_SendWriteRequest(Communication_p); + case SEND_WRITE_REQUEST: + ReturnValue = R15_Bulk_SendWriteRequest(Communication_p); - if (E_SUCCESS == ReturnValue) { - BulkVector_p->State = WAIT_READ_REQUEST; - } + if (E_SUCCESS == ReturnValue) { + BulkVector_p->State = WAIT_READ_REQUEST; + } - break; + break; - case WAIT_BULK_ACK: - //...? - break; + case WAIT_BULK_ACK: + //...? + break; - case WAIT_READ_REQUEST: + case WAIT_READ_REQUEST: #ifndef CFG_ENABLE_LOADER_TYPE - //TODO find end release timer for retransmission - BulkVector_p->State = PROCESSING_CHUNKS; - /* FALLTHROUGH */ + //TODO find end release timer for retransmision + BulkVector_p->State = SENDING_CHUNKS; + /* FALLTHROUGH */ #else - //... - break; + //... + break; #endif - case PROCESSING_CHUNKS: - /* Find ChunkId for a package that needs processing. */ - ProcessingChunkId = R15_Bulk_GetChunkForSeriazliation(BulkVector_p); - - if (ProcessingChunkId <= BulkVector_p->Buffers - 1) { - R15_Bulk_SerializeChunk(Communication_p, BulkVector_p->Entries[ProcessingChunkId].Buffer_p, ProcessingChunkId); - } - - /* Find ChunkId for a package that is processed and ready for sending. */ - BulkVector_p->SendingChunkId = R15_Bulk_GetChunkForSending(BulkVector_p); - - if (BulkVector_p->SendingChunkId <= BulkVector_p->Buffers - 1) { - /* Move to state to process remaining chunks while waiting - for the current chunk to be sent */ - BulkVector_p->State = WAIT_CHUNK_SENT; - /* Send packet with chunk ID */ - R15_Bulk_SendData(Communication_p, BulkVector_p->Entries[BulkVector_p->SendingChunkId].Buffer_p); + /* continue to send chunks */ + case SENDING_CHUNKS: + /* get Chunk ID of next packet! */ + ChunkId = R15_Bulk_GetNextPacketChunkId(BulkVector_p); + + if (ChunkId <= BulkVector_p->Buffers - 1) { + /* get and send packet with chunk ID */ + R15_Bulk_SendData(Communication_p, BulkVector_p->Entries[ChunkId].Buffer_p, ChunkId); #ifndef CFG_ENABLE_LOADER_TYPE - if (NULL != R15_TRANSPORT(Communication_p)->BulkDataCallback_p) { - BulkDataReqCallback_t pcbf = (BulkDataReqCallback_t)R15_TRANSPORT(Communication_p)->BulkDataCallback_p; - BulkVector_p->TransferedLength += BulkVector_p->ChunkSize; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, BulkVector_p->TotalLength, BulkVector_p->TransferedLength); - } + if (NULL != R15_TRANSPORT(Communication_p)->BulkDataCallback_p) { + BulkDataReqCallback_t pcbf; + SESSION(Communication_p) = BulkVector_p->SessionId; + CHUNKSIZE(Communication_p) = BulkVector_p->ChunkSize; + OFFSET(Communication_p) = BulkVector_p->Offset; + LENGTH(Communication_p) = BulkVector_p->Length; + TRANSFEREDLENGTH(Communication_p) += CHUNKSIZE(Communication_p); + pcbf = (BulkDataReqCallback_t)R15_TRANSPORT(Communication_p)->BulkDataCallback_p; + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), &TOTALLENGTH(Communication_p), &TRANSFEREDLENGTH(Communication_p)); + } #endif - C_(printf("bulk_protocol.c(%d) Sent chunk (%d) session (%d)\n", __LINE__, ChunkId, BulkVector_p->SessionId);) - } - - break; + C_(printf("bulk_protocol.c(%d) Sent chunk (%d) session (%d)\n", __LINE__, ChunkId, BulkVector_p->SessionId);) - case WAIT_CHUNK_SENT: + } else { + /* all chunks are in process of sending, wait for chunks to be sent */ - /* Wait for the chunk to be sent in order to continue sending next chunks */ - if (CHECK_PACKET_FLAGS(BulkVector_p->Entries[BulkVector_p->SendingChunkId].Buffer_p, BUF_TX_SENT)) { - BulkVector_p->State = PROCESSING_CHUNKS; - } else { - /* While sending the chunk prepare other chunks for sending. */ - ProcessingChunkId = R15_Bulk_GetChunkForSeriazliation(BulkVector_p); - if (ProcessingChunkId <= BulkVector_p->Buffers - 1) { - R15_Bulk_SerializeChunk(Communication_p, BulkVector_p->Entries[ProcessingChunkId].Buffer_p, ProcessingChunkId); - } else if (R15_Bulk_AllChunksProcessed(BulkVector_p)) { - BulkVector_p->State = SENDING_CHUNKS; - } - } + if (R15_Bulk_CheckTransmitedChunks(BulkVector_p)) { + /* save the current bulk vector before bulk session is closed */ + memcpy(&(R15_TRANSPORT(Communication_p))->PreviousBulkVector, BulkVector_p, sizeof(TL_BulkVectorList_t)); + R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = R15_Bulk_GetTimerChunkRetransmision(Communication_p, R15_TIMEOUTS(Communication_p)->TBCR, (HandleFunction_t)R15_Bulk_RetransmitChunks_CallBack); + BulkVector_p->State = WAIT_BULK_ACK; + C_(printf("bulk_protocol.c(%d) Wait BULK ACK for session (%d)!\n", __LINE__, BulkVector_p->SessionId);) - break; - case SENDING_CHUNKS: - - if (R15_Bulk_CheckTransmitedChunks(BulkVector_p)) { - /* save the current bulk vector before bulk session is closed */ - memcpy(&(R15_TRANSPORT(Communication_p))->PreviousBulkVector, BulkVector_p, sizeof(TL_BulkVectorList_t)); - R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = R15_Bulk_GetTimerChunkRetransmision(Communication_p, R15_TIMEOUTS(Communication_p)->TBCR, (HandleFunction_t)R15_Bulk_RetransmitChunks_CallBack); - BulkVector_p->State = WAIT_BULK_ACK; - C_(printf("bulk_protocol.c(%d) Wait BULK ACK for session (%d)!\n", __LINE__, BulkVector_p->SessionId);) - } else if (CHECK_PACKET_FLAGS(BulkVector_p->Entries[BulkVector_p->SendingChunkId].Buffer_p, BUF_TX_SENT)) { - /* Get Chunk ID of next packet! */ - BulkVector_p->SendingChunkId = R15_Bulk_GetChunkForSending(BulkVector_p); - - if (BulkVector_p->SendingChunkId <= BulkVector_p->Buffers - 1) { - /* Send packet with chunk ID */ - R15_Bulk_SendData(Communication_p, BulkVector_p->Entries[BulkVector_p->SendingChunkId].Buffer_p); -#ifndef CFG_ENABLE_LOADER_TYPE - if (NULL != R15_TRANSPORT(Communication_p)->BulkDataCallback_p) { - BulkDataReqCallback_t pcbf = (BulkDataReqCallback_t)R15_TRANSPORT(Communication_p)->BulkDataCallback_p; - BulkVector_p->TransferedLength += BulkVector_p->ChunkSize; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, BulkVector_p->TotalLength, BulkVector_p->TransferedLength); } - -#endif - C_(printf("bulk_protocol.c(%d) Sent chunk (%d) session (%d)\n", __LINE__, ChunkId, BulkVector_p->SessionId);) } - } #ifdef CFG_ENABLE_MEASUREMENT_TOOL - ReturnValue = MP(Measurement_p, ChunkId, RECEIVED_CHUNK_TIME); + ReturnValue = MP(Measurement_p, ChunkId, RECEIVED_CHUNK_TIME); #endif - break; + break; -#ifndef CFG_ENABLE_LOADER_TYPE - case WAIT_TX_DONE: - /* Wait for all chunks in the current session to be send before closing - the current session and notifying start of the new session */ - if (R15_Bulk_SessionTxDone(BulkVector_p)) { - // notify session end - BulkCommandReqCallback_t pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, TRUE); - // close the current bulk session - (void)Do_R15_Bulk_CloseSession(Communication_p, BulkVector_p); //TODO: da se hendla return vrednosta! - BulkExtendedHeader_t *PendingHeader_p = R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p; + case WRITE_BULK_FINISH: + BulkVector_p->State = BULK_IDLE_STATE; + BulkVector_p->Status = BULK_SESSION_FINISHED; + C_(printf("bulk_protocol.c(%d) Write bulk process finished! \n", __LINE__);) + break; - if (NULL != PendingHeader_p) { - // set bulk parameters for new bulk session if request for starting new session was received - pcbf(Communication_p->Object_p, PendingHeader_p->Session, PendingHeader_p->ChunkSize, PendingHeader_p->Offset, PendingHeader_p->Length, FALSE); - BUFFER_FREE(R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p); - } + default: + BulkVector_p->State = BULK_IDLE_STATE; + break; } - - break; -#endif - - case WRITE_BULK_FINISH: - BulkVector_p->State = BULK_IDLE_STATE; - BulkVector_p->Status = BULK_SESSION_FINISHED; - C_(printf("bulk_protocol.c(%d) Write bulk process finished! \n", __LINE__);) - break; - - default: - BulkVector_p->State = BULK_IDLE_STATE; - break; } - } - Do_CriticalSection_Leave(R15_TRANSPORT(Communication_p)->BulkHandle.BulkTransferCS); + reentrant = 1; + } return ReturnValue; } @@ -1059,103 +983,105 @@ static ErrorCode_e R15_Bulk_SendWriteRequest(Communication_t *Communication_p) return ReturnValue; } -static void R15_Bulk_SerializeChunk(Communication_t *Communication_p, PacketMeta_t *Packet_p, uint32 ChunkId) + +static void R15_Bulk_SendData(Communication_t *Communication_p, PacketMeta_t *Packet_p, uint32 ChunkId) { BulkExtendedHeader_t ExtendedHeader; - R15_Header_t Header; + R15_Header_t Header; TL_BulkVectorList_t *BulkVector_p = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p; uint32 DeltaLength = 0; - Packet_p->Timer_p = NULL; - Packet_p->Resend = 0; - /* set call back function */ - Packet_p->CallBack_p = NULL; + /* check if packet is already serialized and calculated */ + if (!CHECK_PACKET_FLAGS(Packet_p, (BUF_ALLOCATED | BUF_TX_READY | BUF_PAYLOAD_CRC_CALCULATED))) { + Packet_p->Timer_p = NULL; + Packet_p->Resend = 0; + /* set call back function */ + Packet_p->CallBack_p = NULL; - /* setup header data */ - memset(&Header, 0, HEADER_LENGTH); - Header.Protocol = BULK_PROTOCOL; - Header.Flags = Communication_p->CurrentFamilyHash; + /* setup header data */ + memset(&Header, 0, HEADER_LENGTH); + Header.Protocol = BULK_PROTOCOL; + Header.Flags = Communication_p->CurrentFamilyHash; - if ((ChunkId + 1) == BulkVector_p->Buffers) { - DeltaLength = (ChunkId + 1) * BulkVector_p->ChunkSize - BulkVector_p->Length; + if ((ChunkId + 1) == BulkVector_p->Buffers) { + DeltaLength = (ChunkId + 1) * BulkVector_p->ChunkSize - BulkVector_p->Length; - if (DeltaLength == 0) { - Header.PayloadLength = BulkVector_p->ChunkSize; + if (DeltaLength == 0) { + Header.PayloadLength = BulkVector_p->ChunkSize; + } else { + Header.PayloadLength = BulkVector_p->ChunkSize - DeltaLength; + } } else { - Header.PayloadLength = BulkVector_p->ChunkSize - DeltaLength; + Header.PayloadLength = BulkVector_p->ChunkSize; } - } else { - Header.PayloadLength = BulkVector_p->ChunkSize; - } - - Header.ExtendedHeaderLength = BULK_EXTENDED_HEADER_LENGTH; - /* Set extended header parameters */ - ExtendedHeader.Session = BulkVector_p->SessionId; - ExtendedHeader.AcksChunk = (uint8)ChunkId; - ExtendedHeader.ChunkSize = BulkVector_p->ChunkSize; - ExtendedHeader.Offset = BulkVector_p->Offset; - ExtendedHeader.Length = BulkVector_p->Length; - ExtendedHeader.TypeFlags = CMD_BULK_DATA; - - /* serialize and calculate extended header */ - Packet_p->ExtendedHeader_p = Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER + ALIGNED_HEADER_LENGTH; - R15_SerializeExtendedHeader(Packet_p->ExtendedHeader_p, Header.Protocol, &ExtendedHeader, &(Header.ExtendedHeaderChecksum)); - /* setup header for serialization and calculation */ - memcpy(&Packet_p->Header, &Header, HEADER_LENGTH); - - /* Calculate Payload CRC */ - Packet_p->Communication_p = Communication_p; - SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_CRC_CALCULATING); - - if (HASH_NONE != Packet_p->Header.Flags) { - Communication_p->HashDevice_p->Calculate(OBJECT_HASH(Communication_p), - (HashType_e)Packet_p->Header.Flags, - (void *)Packet_p->Payload_p, Packet_p->Header.PayloadLength, - Packet_p->Hash, (HashCallback_t)R15_Bulk_OutHashCallback, - (void *)Packet_p); + Header.ExtendedHeaderLength = BULK_EXTENDED_HEADER_LENGTH; + + /* Set extended header parameters */ + ExtendedHeader.Session = BulkVector_p->SessionId; + ExtendedHeader.AcksChunk = (uint8)ChunkId; + ExtendedHeader.ChunkSize = BulkVector_p->ChunkSize; + ExtendedHeader.Offset = BulkVector_p->Offset; + ExtendedHeader.Length = BulkVector_p->Length; + ExtendedHeader.TypeFlags = CMD_BULK_DATA; + + /* serialize and calculate extended header */ + Packet_p->ExtendedHeader_p = Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER + ALIGNED_HEADER_LENGTH; + R15_SerializeExtendedHeader(Packet_p->ExtendedHeader_p, Header.Protocol, &ExtendedHeader, &(Header.ExtendedHeaderChecksum)); + /* setup header for serialization and calculation */ + memcpy(&Packet_p->Header, &Header, HEADER_LENGTH); + + /* Calculate Payload CRC */ + Packet_p->Communication_p = Communication_p; + SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_CRC_CALCULATING); + + if (HASH_NONE != Packet_p->Header.Flags) { + Communication_p->HashDevice_p->Calculate(OBJECT_HASH(Communication_p), + (HashType_e)Packet_p->Header.Flags, + (void *)Packet_p->Payload_p, Packet_p->Header.PayloadLength, + Packet_p->Hash, (HashCallback_t)R15_Bulk_OutHashCallback, + (void *)Packet_p); + } else { + SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_PAYLOAD_CRC_CALCULATED); + memset(&Packet_p->Header.PayloadChecksum, 0x0, sizeof(uint32)); + //SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_HEADER_CRC_CALCULATED); + R15_SerializeHeader(Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER, &Packet_p->Header); + (void)QUEUE(Packet_p->Communication_p, FifoEnqueue_Fn)(OBJECT_QUEUE(Packet_p->Communication_p), Packet_p->Communication_p->Outbound_p, Packet_p); + } } else { - memset(&Packet_p->Header.PayloadChecksum, 0x0, sizeof(uint32)); - R15_SerializeHeader(Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER, &Packet_p->Header); - SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_PAYLOAD_CRC_CALCULATED); + (void)QUEUE(Packet_p->Communication_p, FifoEnqueue_Fn)(OBJECT_QUEUE(Packet_p->Communication_p), Packet_p->Communication_p->Outbound_p, Packet_p); } -} -static void R15_Bulk_SendData(Communication_t *Communication_p, PacketMeta_t *Packet_p) -{ - SET_PACKET_FLAGS(Packet_p, PACKET_TX_STATE_MASK, BUF_TX_SENDING); - (void)QUEUE(Packet_p->Communication_p, FifoEnqueue_Fn)(OBJECT_QUEUE(Packet_p->Communication_p), Packet_p->Communication_p->Outbound_p, Packet_p); + /* mark packet as sent */ + SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_SENDING); } static void R15_Bulk_OutHashCallback(const void *const Data_p, uint32 Length, const uint8 *const Hash_p, void *Param_p) { PacketMeta_t *Packet_p = (PacketMeta_t *)Param_p; + SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_PAYLOAD_CRC_CALCULATED); memcpy(&Packet_p->Header.PayloadChecksum, Hash_p, sizeof(uint32)); - R15_SerializeHeader(Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER, &Packet_p->Header); - SET_PACKET_FLAGS(Packet_p, PACKET_CRC_STATE_MASK, BUF_PAYLOAD_CRC_CALCULATED); + R15_SerializeHeader(Packet_p->Buffer_p + HEADER_OFFSET_IN_BUFFER, &Packet_p->Header); + (void)QUEUE(Packet_p->Communication_p, FifoEnqueue_Fn)(OBJECT_QUEUE(Packet_p->Communication_p), Packet_p->Communication_p->Outbound_p, Packet_p); } static void R15_Bulk_ReadChunkCallBack(Communication_t *Communication_p, const void *const Timer_p, const void *const Data_p) { - TL_BulkVectorList_t *BulkVector_p = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p; - - if (BULK_SESSION_FINISHED != BulkVector_p->Status) { - uint32 ChunkId = 0; - uint8 ChunksList[MAX_BULK_TL_PROCESSES] = {0}; - - R15_Bulk_GetListOfReceivedChunks(BulkVector_p, &ChunkId, ChunksList); - BulkVector_p->State = WAIT_CHUNKS; + R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->State = WAIT_CHUNKS; + (void)QUEUE((Communication_p), FifoEnqueue_Fn)(OBJECT_QUEUE(Communication_p), Communication_p->Outbound_p, (void *)Data_p); +} - (void)R15_Bulk_SendReadRequest(Communication_p, BulkVector_p, ChunkId, ChunksList, NULL); - } +static void R15_Bulk_ReadDataChunkCallBack(Communication_t *Communication_p, const void *const Timer_p, const void *const Data_p) +{ + (void)R15_Bulk_SendReadRequest(Communication_p, RetransmissionRequest.BulkVector_p, RetransmissionRequest.ChunkId, RetransmissionRequest.ChunksList_p, NULL); } static void R15_Bulk_RetransmitChunks_CallBack(const Communication_t *const Communication_p, const void *const Timer_p, const void *const Data_p) { - /* Set all chunks for retransmission. Max retransmission is 3. */ + /* set all chunks for retransmision . Max retransmision is 3. */ uint32 ChunkId; PacketMeta_t *Packet_p; @@ -1165,7 +1091,7 @@ static void R15_Bulk_RetransmitChunks_CallBack(const Communication_t *const Comm SET_PACKET_FLAGS(Packet_p, PACKET_TX_STATE_MASK, BUF_TX_READY); } - R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->State = PROCESSING_CHUNKS; + R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->State = SENDING_CHUNKS; } static void R15_Bulk_GetListOfReceivedChunks(const TL_BulkVectorList_t *const BulkVector_p, uint32 *Chunks_p, uint8 *ChunkList_p) @@ -1181,46 +1107,7 @@ static void R15_Bulk_GetListOfReceivedChunks(const TL_BulkVectorList_t *const Bu } } -static boolean R15_Bulk_AllChunksProcessed(const TL_BulkVectorList_t *const BulkVector_p) -{ - boolean Status = TRUE; - uint32 ChunkId; - - for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - if (!CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_PAYLOAD_CRC_CALCULATED)) { - Status = FALSE; - break; - } - } - - return Status; -} - #ifndef CFG_ENABLE_LOADER_TYPE -/* Check if all chunks are sent. - * - * Returns FALSE if some of the chunks is in process of sending, otherwise returns TRUE. - * Needed to decide if current session can be closed immediately or should wait for - * chunk to finish transmission in order to close the session and destroy vector. - */ -static boolean R15_Bulk_SessionTxDone(const TL_BulkVectorList_t *const BulkVector_p) -{ - boolean Status = TRUE; - uint32 ChunkId; - - for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - if (CHECK_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, BUF_TX_SENDING)) { - /* If some of chunks is in process of sending return FALSE */ - Status = FALSE; - } else { - /* All chunks are acknowledged, set TX_DONE for packages that are not in process of sending */ - SET_PACKET_FLAGS(BulkVector_p->Entries[ChunkId].Buffer_p, PACKET_TX_STATE_MASK, BUF_TX_DONE); - } - } - - return Status; -} - static boolean IsChunkReceived(Communication_t *Communication_p, uint32 ChunkId) { PacketMeta_t *Packet_p = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->Entries[ChunkId].Buffer_p; @@ -1252,8 +1139,7 @@ static TL_BulkVectorStatus_t R15_Bulk_GetVectorStatus(TL_BulkVectorList_t *BulkV for (ChunkCounter = 0; ChunkCounter < BulkVector_p->Buffers; ChunkCounter++) { Packet_p = BulkVector_p->Entries[ChunkCounter].Buffer_p; - if (Packet_p == NULL || - !(CHECK_PACKET_FLAGS(Packet_p, BUF_ACK_READY) || CHECK_PACKET_FLAGS(Packet_p, BUF_ACKNOWLEDGED))) { + if (Packet_p == NULL || !(CHECK_PACKET_FLAGS(Packet_p, BUF_ACK_READY) || CHECK_PACKET_FLAGS(Packet_p, BUF_ACKNOWLEDGED))) { Status = VECTOR_NOT_COMPLETE; } else { if (Status == VECTOR_NOT_COMPLETE) { @@ -1266,43 +1152,6 @@ static TL_BulkVectorStatus_t R15_Bulk_GetVectorStatus(TL_BulkVectorList_t *BulkV return Status; } -/* Determine if it is needed to send ReadRequest for retransmission of missing chunk(s). - * - * Function checks if the missing chunk(s) until the currently received chunk was - * requested to be retransmitted earlier. If not it sets RetransmissionRequested - * to all the missing chunks and decides that sending of ReadRequest is needed. - * - */ -static boolean R15_Bulk_VectorNeedsRetransmission(TL_BulkVectorList_t *BulkVector_p, uint32 CurrentChunkId) -{ - boolean Status = FALSE; - uint32 ChunkId; - - for (ChunkId = 0; ChunkId <= CurrentChunkId; ChunkId++) { - if (NULL == BulkVector_p->Entries[ChunkId].Buffer_p) { - if (FALSE == BulkVector_p->Entries[ChunkId].RetransmissionRequested) { - BulkVector_p->Entries[ChunkId].RetransmissionRequested = TRUE; - Status = TRUE; - } - } - } - - return Status; -} - -/* - * Clear RetransmissionRequested flag for all chunks in the given bulk vector. - * - */ -static void R15_Bulk_VectorClearRetransmissionRequested(TL_BulkVectorList_t *BulkVector_p) -{ - uint32 ChunkId; - - for (ChunkId = 0; ChunkId < BulkVector_p->Buffers; ChunkId++) { - BulkVector_p->Entries[ChunkId].RetransmissionRequested = FALSE; - } -} - static uint32 R15_Bulk_GetTimerChunkRetransmision(const Communication_t *const Communication_p, uint32 Time, HandleFunction_t CallBack_p) { Timer_t Timer; @@ -1340,9 +1189,9 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, // check witch chunks are acknowledged! if (Packet_p->Header.PayloadLength > 0) { if (!R15_Bulk_CheckAcknowledgedChunks(BulkVector_p, Packet_p->Payload_p)) { - /* mark all not acknowledged chunks for retransmission */ + /* mark all not ackonwledged chunks for retransmision */ R15_Bulk_MarkNotAckChunks(BulkVector_p, Packet_p->Payload_p, ExtendedHeader.AcksChunk); - BulkVector_p->State = PROCESSING_CHUNKS; + BulkVector_p->State = SENDING_CHUNKS; } else { BulkVector_p->State = WRITE_BULK_FINISH; } @@ -1353,9 +1202,8 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = 0; } } else { - if ((BulkVector_p->State == PROCESSING_CHUNKS) || (BulkVector_p->State == SENDING_CHUNKS) || - (BulkVector_p->State == WAIT_CHUNK_SENT) || (BulkVector_p->State == WAIT_BULK_ACK)) { - /* mark all chunks for retransmission */ + if ((BulkVector_p->State == SENDING_CHUNKS) || (BulkVector_p->State == WAIT_BULK_ACK)) { + /* mark all chunks for retransmision */ R15_Bulk_MarkNotAckAllChunks(BulkVector_p); } else { /* release the buffer for previous command BULK WRITE */ @@ -1364,7 +1212,7 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, VERIFY((E_SUCCESS == ReturnValue) || (E_NOT_FOUND_ELEMENT_IN_RETRANSMISSION_LIST == ReturnValue), ReturnValue); } - BulkVector_p->State = PROCESSING_CHUNKS; + BulkVector_p->State = SENDING_CHUNKS; } ReturnValue = R15_Bulk_Process_Write(Communication_p, BulkVector_p); // state machine for WRITE BULK data @@ -1374,7 +1222,7 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, C_(printf("bulk_protocol.c(%d) Received READ packet!\n", __LINE__);) C_(printf("bulk_protocol.c(%d) Session (%d)!\n", __LINE__, ExtendedHeader.Session);) - /* Check the ACK */ + /*ckeck the ACK */ if (NULL != R15_TRANSPORT(Communication_p)->BulkCommandCallback_p) { // check the session ID of the received packet if (BULK_SESSION_NEW == BulkSessionIDStatus) { @@ -1386,28 +1234,20 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, C_(printf("bulk_protocol.c(%d) Current: Session (%d)!\n", __LINE__, BulkVector_p->SessionId);) C_(printf("bulk_protocol.c(%d) ReceivedPacket: Session (%d)!\n", __LINE__, ExtendedHeader.Session);) - if (R15_Bulk_SessionTxDone(BulkVector_p)) { - // notify session end - pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, TRUE); - - // close the current bulk session - (void)Do_R15_Bulk_CloseSession(Communication_p, BulkVector_p); //TODO: da se hendla return vrednosta! - - // set bulk parameters for new bulk session - ACK_Read = FALSE; - pcbf(Communication_p->Object_p, ExtendedHeader.Session, ExtendedHeader.ChunkSize, ExtendedHeader.Offset, ExtendedHeader.Length, ACK_Read); - } else { - /* Clean the previous saved data if there is any */ - BUFFER_FREE(R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p); - - /* Save the received extended header for the new bulk session */ - R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p = (BulkExtendedHeader_t *)malloc(sizeof(BulkExtendedHeader_t)); - memcpy(R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p, &ExtendedHeader, sizeof(BulkExtendedHeader_t)); + // close the current bulk session + (void)Do_R15_Bulk_CloseSession(Communication_p, BulkVector_p); //TODO: da se hendla return vrednosta! - /* Wait for all chunks which are in process of sending to be sent before opening a new session */ - BulkVector_p->State = WAIT_TX_DONE; - } + // notify session end + pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; + pcbf(Communication_p->Object_p, &BulkVector_p->SessionId, &BulkVector_p->ChunkSize, &BulkVector_p->Offset, &BulkVector_p->Length, TRUE); + + // set bulk parameters for new bulk session + ACK_Read = FALSE; + SESSION(Communication_p) = ExtendedHeader.Session; + CHUNKSIZE(Communication_p) = ExtendedHeader.ChunkSize; + OFFSET(Communication_p) = ExtendedHeader.Offset; + LENGTH(Communication_p) = ExtendedHeader.Length; + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), ACK_Read); } else { // can't be opened new bulk session until current session is not finished. goto ErrorExit; @@ -1416,54 +1256,57 @@ static ErrorCode_e R15_Bulk_ReadRequestHandler(Communication_t *Communication_p, C_(printf("bulk_protocol.c(%d) Request for new bulk session!\n", __LINE__);) // received request for new bulk session ACK_Read = FALSE; + SESSION(Communication_p) = ExtendedHeader.Session; + CHUNKSIZE(Communication_p) = ExtendedHeader.ChunkSize; + OFFSET(Communication_p) = ExtendedHeader.Offset; + LENGTH(Communication_p) = ExtendedHeader.Length; pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, ExtendedHeader.Session, ExtendedHeader.ChunkSize, ExtendedHeader.Offset, ExtendedHeader.Length, ACK_Read); + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), ACK_Read); + R15_Bulk_ClearBulkTmpParam(Communication_p); } } else { // current bulk session Buffers = ((ExtendedHeader.Length + ExtendedHeader.ChunkSize - 1) / ExtendedHeader.ChunkSize); - if ((0 == ExtendedHeader.AcksChunk) && - (Do_R15_Bulk_GetStatusSession(R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p) == BULK_SESSION_IDLE)) { - C_(printf("bulk_protocol.c(%d) Request for new bulk session(%d)!\n", __LINE__, ExtendedHeader.Session);) - - /* Try to release the timer for the bulk session acknowledge */ - if (R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey > 0) { - (void)TIMER(Communication_p, TimerRelease_Fn)(OBJECT_TIMER(Communication_p), R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey); // LCM MB bug fix: Timer should be released on request for retransmission - R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = 0; - } - - ACK_Read = FALSE; - pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, ExtendedHeader.Session, ExtendedHeader.ChunkSize, ExtendedHeader.Offset, ExtendedHeader.Length, ACK_Read); - } else if (Buffers == ExtendedHeader.AcksChunk) { - C_(printf("bulk_protocol.c(%d) ACK for bulk session(%d)!\n", __LINE__, ExtendedHeader.Session);) - (void)TIMER(Communication_p, TimerRelease_Fn)(OBJECT_TIMER(Communication_p), R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey); + if (((ExtendedHeader.AcksChunk == 0) && (Do_R15_Bulk_GetStatusSession(R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p) == BULK_SESSION_IDLE)) || (ExtendedHeader.AcksChunk == Buffers)) { + //BulkCommandReqCallback_t pcbf; + if (Buffers == ExtendedHeader.AcksChunk) { + C_(printf("bulk_protocol.c(%d) ACK for bulk session(%d)!\n", __LINE__, ExtendedHeader.Session);) + (void)TIMER(Communication_p, TimerRelease_Fn)(OBJECT_TIMER(Communication_p), R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey); + (void)Do_R15_Bulk_CloseSession(Communication_p, BulkVector_p); //TODO: da se hendla return vrednosta! - if (R15_Bulk_SessionTxDone(BulkVector_p)) { // notify session end pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, TRUE); - - (void)Do_R15_Bulk_CloseSession(Communication_p, BulkVector_p); //TODO: da se hendla return vrednosta! + pcbf(Communication_p->Object_p, &BulkVector_p->SessionId, &BulkVector_p->ChunkSize, &BulkVector_p->Offset, &BulkVector_p->Length, TRUE); } else { - /* Clean the previous saved data if there is any */ - BUFFER_FREE(R15_TRANSPORT(Communication_p)->BulkHandle.PendingBulkHeader_p); + C_(printf("bulk_protocol.c(%d) Request for new bulk session(%d)!\n", __LINE__, ExtendedHeader.Session);) + ACK_Read = FALSE; + SESSION(Communication_p) = ExtendedHeader.Session; + CHUNKSIZE(Communication_p) = ExtendedHeader.ChunkSize; + OFFSET(Communication_p) = ExtendedHeader.Offset; + LENGTH(Communication_p) = ExtendedHeader.Length; + + /* Try to release the timer for the bulk session acknowledge */ + if (R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey > 0) { + (void)TIMER(Communication_p, TimerRelease_Fn)(OBJECT_TIMER(Communication_p), R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey); // LCM MB bug fix: Timer should be released on request for retransmission + R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey = 0; + } - /* Wait for all chunks of current session to be sent before opening new session */ - BulkVector_p->State = WAIT_TX_DONE; + pcbf = (BulkCommandReqCallback_t)R15_TRANSPORT(Communication_p)->BulkCommandCallback_p; + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), ACK_Read); + R15_Bulk_ClearBulkTmpParam(Communication_p); } } else { - if (0 == ExtendedHeader.AcksChunk) { - /* mark all chunks for retransmission */ + if (ExtendedHeader.AcksChunk == 0) { + /* mark all chunks for retransmision */ R15_Bulk_MarkNotAckAllChunks(BulkVector_p); } else { - /* mark all not acknowledged chunks for retransmission */ + /* mark all not ackonwledged chunks for retransmision */ A_(printf("bulk_protocol.c (%d): Mark All NACK Chunks for Retransmission **\n", __LINE__);) R15_Bulk_MarkNotAckChunks(BulkVector_p, Packet_p->Payload_p, ExtendedHeader.AcksChunk); } - BulkVector_p->State = PROCESSING_CHUNKS; + BulkVector_p->State = SENDING_CHUNKS; /* Try to release the timer for the bulk session acknowledge */ if (R15_TRANSPORT(Communication_p)->BulkHandle.TimerKey > 0) { @@ -1534,10 +1377,14 @@ static ErrorCode_e R15_Bulk_DataRequestHandler(Communication_t *Communication_p, ChunkId = ExtendedHeader.AcksChunk; if (!IsChunkReceived(Communication_p, ChunkId)) { - BulkVector_p->TransferedLength += BulkVector_p->ChunkSize; + SESSION(Communication_p) = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->SessionId; + CHUNKSIZE(Communication_p) = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->ChunkSize; + OFFSET(Communication_p) = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->Offset; + LENGTH(Communication_p) = R15_TRANSPORT(Communication_p)->BulkHandle.BulkVector_p->Length; + TRANSFEREDLENGTH(Communication_p) += CHUNKSIZE(Communication_p); pcbf = (BulkDataReqCallback_t)R15_TRANSPORT(Communication_p)->BulkDataCallback_p; - pcbf(Communication_p->Object_p, BulkVector_p->SessionId, BulkVector_p->ChunkSize, BulkVector_p->Offset, BulkVector_p->Length, BulkVector_p->TotalLength, BulkVector_p->TransferedLength); - C_(printf("S(%d) L(%d) CS(%d)\n", BulkVector_p->SessionId, BulkVector_p->Length, BulkVector_p->ChunkSize);) //xvsvlpi + pcbf(Communication_p->Object_p, &SESSION(Communication_p), &CHUNKSIZE(Communication_p), &OFFSET(Communication_p), &LENGTH(Communication_p), &TOTALLENGTH(Communication_p), &TRANSFEREDLENGTH(Communication_p)); + C_(printf("S(%d) L(%d) CS(%d)\n", SESSION(Communication_p), LENGTH(Communication_p), CHUNKSIZE(Communication_p));) //xvsvlpi } } @@ -1608,6 +1455,23 @@ static TL_BulkSessionID_Status_t R15_Bulk_CheckBulkSession(Communication_t *Comm return ReturnStatus; } +#ifndef CFG_ENABLE_LOADER_TYPE +/* + * Clear temporary saved bulk parameters + * + * @param[in] Communication_p Communication module context. + * + * return none. + */ +static void R15_Bulk_ClearBulkTmpParam(Communication_t *Communication_p) +{ + SESSION(Communication_p) = 0; + CHUNKSIZE(Communication_p) = 0; + OFFSET(Communication_p) = 0; + LENGTH(Communication_p) = 0; +} +#endif + /** @} */ /** @} */ /** @} */ |