35 #define XCP_ENABLE_STD_COMMANDS XCP_ON 36 #define XCP_ENABLE_INTERLEAVED_MODE XCP_OFF 38 #define XCP_DRIVER_VERSION (10) 43 XCP_STATIC
const Xcp_GetIdType Xcp_GetId0 = XCP_SET_ID(XCP_GET_ID_0);
44 XCP_STATIC
const Xcp_GetIdType Xcp_GetId1 = XCP_SET_ID(XCP_GET_ID_1);
49 XCP_STATIC Xcp_ConnectionStateType Xcp_ConnectionState = XCP_DISCONNECTED;
50 XCP_STATIC Xcp_StateType Xcp_State;
51 XCP_STATIC Xcp_SendCalloutType Xcp_SendCallout = (Xcp_SendCalloutType)XCP_NULL;
52 static uint8_t Xcp_CtoOutBuffer[XCP_TRANSPORT_LAYER_CTO_BUFFER_SIZE] = {0};
53 static uint8_t Xcp_CtoInBuffer[XCP_TRANSPORT_LAYER_CTO_BUFFER_SIZE] = {0};
58 Xcp_PduType Xcp_CtoIn = {0, &Xcp_CtoInBuffer[0]};
59 Xcp_PduType Xcp_CtoOut = {0, &Xcp_CtoOutBuffer[0]};
61 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 62 static uint8_t Xcp_DtoOutBuffer[XCP_TRANSPORT_LAYER_DTO_BUFFER_SIZE] = {0};
63 static Xcp_PduType Xcp_DtoOut = {0, &Xcp_DtoOutBuffer[0]};
66 void Xcp_WriteMemory(
void *dest,
void *src, uint16_t count);
68 void Xcp_ReadMemory(
void *dest,
void *src, uint16_t count);
73 #define STOP_ALL UINT8(0x00) 74 #define START_SELECTED UINT8(0x01) 75 #define STOP_SELECTED UINT8(0x02) 77 #define XCP_INCREMENT_MTA(i) Xcp_State.mta.address += UINT32((i)) 79 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 80 #define XCP_ASSERT_DAQ_STOPPED() \ 82 if (Xcp_State.daqProcessor.state == XCP_DAQ_STATE_RUNNING) { \ 83 Xcp_SendResult(ERR_DAQ_ACTIVE); \ 88 #define XCP_ASSERT_DAQ_STOPPED() 91 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 92 #define XCP_ASSERT_PGM_IDLE() \ 94 if (Xcp_State.pgmProcessor.state == XCP_PGM_ACTIVE) { \ 95 Xcp_SendResult(ERR_PGM_ACTIVE); \ 100 #define XCP_ASSERT_PGM_IDLE() 103 #define XCP_ASSERT_PGM_ACTIVE() \ 105 if (Xcp_State.pgmProcessor.state != XCP_PGM_ACTIVE) { \ 106 Xcp_SendResult(ERR_SEQUENCE); \ 111 #define XCP_ASSERT_UNLOCKED(r) \ 113 if (Xcp_IsProtected((r))) { \ 114 Xcp_SendResult(ERR_ACCESS_LOCKED); \ 119 #if XCP_ENABLE_CHECK_MEMORY_ACCESS == XCP_ON 120 #define XCP_CHECK_MEMORY_ACCESS(m, l, a, p) \ 122 if (!Xcp_HookFunction_CheckMemoryAccess((m), (l), (a), (p))) { \ 123 Xcp_SendResult(ERR_ACCESS_DENIED); \ 128 #define XCP_CHECK_MEMORY_ACCESS(m, l, a, p) 134 XCP_STATIC uint8_t Xcp_SetResetBit8(uint8_t result, uint8_t value,
137 XCP_STATIC Xcp_MemoryMappingResultType Xcp_MapMemory(Xcp_MtaType
const *src,
140 XCP_STATIC
void Xcp_Download_Copy(uint32_t address, uint8_t ext, uint32_t len);
142 XCP_STATIC
void Xcp_PositiveResponse(
void);
144 XCP_STATIC
void Xcp_ErrorResponse(uint8_t errorCode);
146 XCP_STATIC
void Xcp_BusyResponse(
void);
148 #if (XCP_ENABLE_SERVICE_REQUEST_API == XCP_ON) || (XCP_ENABLE_EVENT_PACKET_API) 150 XCP_STATIC
void Xcp_SendSpecialPacket(uint8_t packetType, uint8_t code,
151 uint8_t
const *
const data,
156 XCP_STATIC
bool Xcp_IsProtected(uint8_t resource);
158 XCP_STATIC
void Xcp_DefaultResourceProtection(
void);
160 XCP_STATIC
void Xcp_WriteDaqEntry(uint8_t bitOffset, uint8_t elemSize,
161 uint8_t adddrExt, uint32_t address);
163 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON 164 XCP_STATIC
bool Xcp_SlaveBlockTransferIsActive(
void);
165 XCP_STATIC
void Xcp_SlaveBlockTransferSetActive(
bool onOff);
168 XCP_STATIC
void Xcp_SendResult(Xcp_ReturnType result);
170 XCP_STATIC
void Xcp_CommandNotImplemented_Res(Xcp_PduType
const *
const pdu);
172 XCP_STATIC
void Xcp_Connect_Res(Xcp_PduType
const *
const pdu);
174 XCP_STATIC
void Xcp_Disconnect_Res(Xcp_PduType
const *
const pdu);
176 XCP_STATIC
void Xcp_GetStatus_Res(Xcp_PduType
const *
const pdu);
178 XCP_STATIC
void Xcp_Synch_Res(Xcp_PduType
const *
const pdu);
180 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON 182 XCP_STATIC
void Xcp_GetCommModeInfo_Res(Xcp_PduType
const *
const pdu);
185 #if XCP_ENABLE_GET_ID == XCP_ON 187 XCP_STATIC
void Xcp_GetId_Res(Xcp_PduType
const *
const pdu);
190 #if XCP_ENABLE_SET_REQUEST == XCP_ON 191 XCP_STATIC
void Xcp_SetRequest_Res(Xcp_PduType
const *
const pdu);
193 #if XCP_ENABLE_GET_SEED == XCP_ON 194 XCP_STATIC
void Xcp_GetSeed_Res(Xcp_PduType
const *
const pdu);
196 #if XCP_ENABLE_UNLOCK == XCP_ON 197 XCP_STATIC
void Xcp_Unlock_Res(Xcp_PduType
const *
const pdu);
199 #if XCP_ENABLE_SET_MTA == XCP_ON 201 XCP_STATIC
void Xcp_SetMta_Res(Xcp_PduType
const *
const pdu);
204 #if XCP_ENABLE_UPLOAD == XCP_ON 206 XCP_STATIC
void Xcp_Upload_Res(Xcp_PduType
const *
const pdu);
209 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON 211 XCP_STATIC
void Xcp_ShortUpload_Res(Xcp_PduType
const *
const pdu);
214 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON 216 XCP_STATIC
void Xcp_BuildChecksum_Res(Xcp_PduType
const *
const pdu);
219 #if XCP_ENABLE_TRANSPORT_LAYER_CMD == XCP_ON 220 XCP_STATIC
void Xcp_TransportLayerCmd_Res(Xcp_PduType
const *
const pdu);
222 #if XCP_ENABLE_USER_CMD == XCP_ON 223 XCP_STATIC
void Xcp_UserCmd_Res(Xcp_PduType
const *
const pdu);
226 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON 228 XCP_STATIC
void Xcp_Download_Res(Xcp_PduType
const *
const pdu);
230 #if XCP_ENABLE_DOWNLOAD_NEXT == XCP_ON 231 XCP_STATIC
void Xcp_DownloadNext_Res(Xcp_PduType
const *
const pdu);
233 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON 235 XCP_STATIC
void Xcp_DownloadMax_Res(Xcp_PduType
const *
const pdu);
238 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON 240 XCP_STATIC
void Xcp_ShortDownload_Res(Xcp_PduType
const *
const pdu);
243 #if XCP_ENABLE_MODIFY_BITS == XCP_ON 245 XCP_STATIC
void Xcp_ModifyBits_Res(Xcp_PduType
const *
const pdu);
249 XCP_STATIC
void Xcp_SetCalPage_Res(Xcp_PduType
const *
const pdu);
251 XCP_STATIC
void Xcp_GetCalPage_Res(Xcp_PduType
const *
const pdu);
255 #if XCP_ENABLE_PAG_COMMANDS == XCP_ON 256 #if XCP_ENABLE_GET_PAG_PROCESSOR_INFO == XCP_ON 257 XCP_STATIC
void Xcp_GetPagProcessorInfo_Res(Xcp_PduType
const *
const pdu);
259 #if XCP_ENABLE_GET_SEGMENT_INFO == XCP_ON 260 XCP_STATIC
void Xcp_GetSegmentInfo_Res(Xcp_PduType
const *
const pdu);
262 #if XCP_ENABLE_GET_PAGE_INFO == XCP_ON 263 XCP_STATIC
void Xcp_GetPageInfo_Res(Xcp_PduType
const *
const pdu);
265 #if XCP_ENABLE_SET_SEGMENT_MODE == XCP_ON 266 XCP_STATIC
void Xcp_SetSegmentMode_Res(Xcp_PduType
const *
const pdu);
268 #if XCP_ENABLE_GET_SEGMENT_MODE == XCP_ON 269 XCP_STATIC
void Xcp_GetSegmentMode_Res(Xcp_PduType
const *
const pdu);
271 #if XCP_ENABLE_COPY_CAL_PAGE 272 XCP_STATIC
void Xcp_CopyCalPage_Res(Xcp_PduType
const *
const pdu);
276 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 278 XCP_STATIC
void Xcp_ClearDaqList_Res(Xcp_PduType
const *
const pdu);
280 XCP_STATIC
void Xcp_SetDaqPtr_Res(Xcp_PduType
const *
const pdu);
282 XCP_STATIC
void Xcp_WriteDaq_Res(Xcp_PduType
const *
const pdu);
284 XCP_STATIC
void Xcp_SetDaqListMode_Res(Xcp_PduType
const *
const pdu);
286 XCP_STATIC
void Xcp_GetDaqListMode_Res(Xcp_PduType
const *
const pdu);
288 XCP_STATIC
void Xcp_StartStopDaqList_Res(Xcp_PduType
const *
const pdu);
290 XCP_STATIC
void Xcp_StartStopSynch_Res(Xcp_PduType
const *
const pdu);
292 #if XCP_ENABLE_GET_DAQ_CLOCK == XCP_ON 294 XCP_STATIC
void Xcp_GetDaqClock_Res(Xcp_PduType
const *
const pdu);
297 #if XCP_ENABLE_READ_DAQ == XCP_ON 298 XCP_STATIC
void Xcp_ReadDaq_Res(Xcp_PduType
const *
const pdu);
300 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON 302 XCP_STATIC
void Xcp_GetDaqProcessorInfo_Res(Xcp_PduType
const *
const pdu);
305 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON 307 XCP_STATIC
void Xcp_GetDaqResolutionInfo_Res(Xcp_PduType
const *
const pdu);
310 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON 312 XCP_STATIC
void Xcp_GetDaqListInfo_Res(Xcp_PduType
const *
const pdu);
315 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON 317 XCP_STATIC
void Xcp_GetDaqEventInfo_Res(Xcp_PduType
const *
const pdu);
320 #if XCP_ENABLE_FREE_DAQ == XCP_ON 322 XCP_STATIC
void Xcp_FreeDaq_Res(Xcp_PduType
const *
const pdu);
325 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON 327 XCP_STATIC
void Xcp_AllocDaq_Res(Xcp_PduType
const *
const pdu);
330 #if XCP_ENABLE_ALLOC_ODT == XCP_ON 332 XCP_STATIC
void Xcp_AllocOdt_Res(Xcp_PduType
const *
const pdu);
335 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON 337 XCP_STATIC
void Xcp_AllocOdtEntry_Res(Xcp_PduType
const *
const pdu);
340 #if XCP_ENABLE_WRITE_DAQ_MULTIPLE == XCP_ON 341 XCP_STATIC
void Xcp_WriteDaqMultiple_Res(Xcp_PduType
const *
const pdu);
345 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 347 XCP_STATIC
void Xcp_ProgramStart_Res(Xcp_PduType
const *
const pdu);
349 XCP_STATIC
void Xcp_ProgramClear_Res(Xcp_PduType
const *
const pdu);
351 XCP_STATIC
void Xcp_Program_Res(Xcp_PduType
const *
const pdu);
353 XCP_STATIC
void Xcp_ProgramReset_Res(Xcp_PduType
const *
const pdu);
355 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON 357 XCP_STATIC
void Xcp_GetPgmProcessorInfo_Res(Xcp_PduType
const *
const pdu);
360 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON 362 XCP_STATIC
void Xcp_GetSectorInfo_Res(Xcp_PduType
const *
const pdu);
365 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON 367 XCP_STATIC
void Xcp_ProgramPrepare_Res(Xcp_PduType
const *
const pdu);
370 #if XCP_ENABLE_PROGRAM_FORMAT == XCP_ON 371 XCP_STATIC
void Xcp_ProgramFormat_Res(Xcp_PduType
const *
const pdu);
373 #if XCP_ENABLE_PROGRAM_NEXT == XCP_ON 374 XCP_STATIC
void Xcp_ProgramNext_Res(Xcp_PduType
const *
const pdu);
376 #if XCP_ENABLE_PROGRAM_MAX == XCP_ON 377 XCP_STATIC
void Xcp_ProgramMax_Res(Xcp_PduType
const *
const pdu);
379 #if XCP_ENABLE_PROGRAM_VERIFY == XCP_ON 380 XCP_STATIC
void Xcp_ProgramVerify_Res(Xcp_PduType
const *
const pdu);
388 XCP_STATIC
const Xcp_ServerCommandType Xcp_ServerCommands[] = {
391 #if XCP_ENABLE_STD_COMMANDS == XCP_ON 396 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON 397 Xcp_GetCommModeInfo_Res,
399 Xcp_CommandNotImplemented_Res,
401 #if XCP_ENABLE_GET_ID == XCP_ON 404 Xcp_CommandNotImplemented_Res,
406 #if XCP_ENABLE_SET_REQUEST == XCP_ON 409 Xcp_CommandNotImplemented_Res,
411 #if XCP_ENABLE_GET_SEED == XCP_ON 414 Xcp_CommandNotImplemented_Res,
416 #if XCP_ENABLE_UNLOCK == XCP_ON 419 Xcp_CommandNotImplemented_Res,
421 #if XCP_ENABLE_SET_MTA == XCP_ON 424 Xcp_CommandNotImplemented_Res,
426 #if XCP_ENABLE_UPLOAD == XCP_ON 429 Xcp_CommandNotImplemented_Res,
431 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON 434 Xcp_CommandNotImplemented_Res,
436 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON 437 Xcp_BuildChecksum_Res,
439 Xcp_CommandNotImplemented_Res,
441 #if XCP_ENABLE_TRANSPORT_LAYER_CMD == XCP_ON 442 Xcp_TransportLayerCmd_Res,
444 Xcp_CommandNotImplemented_Res,
446 #if XCP_ENABLE_USER_CMD == XCP_ON 449 Xcp_CommandNotImplemented_Res,
452 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
453 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
454 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
455 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
456 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
457 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
458 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
459 Xcp_CommandNotImplemented_Res,
462 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON 464 #if XCP_ENABLE_DOWNLOAD_NEXT == XCP_ON 465 Xcp_DownloadNext_Res,
467 Xcp_CommandNotImplemented_Res,
469 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON 472 Xcp_CommandNotImplemented_Res,
474 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON 475 Xcp_ShortDownload_Res,
477 Xcp_CommandNotImplemented_Res,
479 #if XCP_ENABLE_MODIFY_BITS == XCP_ON 482 Xcp_CommandNotImplemented_Res,
485 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
486 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
487 Xcp_CommandNotImplemented_Res,
490 #if XCP_ENABLE_PAG_COMMANDS == XCP_ON 493 #if XCP_ENABLE_GET_PAG_PROCESSOR_INFO == XCP_ON 494 Xcp_GetPagProcessorInfo_Res,
496 Xcp_CommandNotImplemented_Res,
498 #if XCP_ENABLE_GET_SEGMENT_INFO == XCP_ON 499 Xcp_GetSegmentInfo_Res,
501 Xcp_CommandNotImplemented_Res,
503 #if XCP_ENABLE_GET_PAGE_INFO == XCP_ON 506 Xcp_CommandNotImplemented_Res,
508 #if XCP_ENABLE_SET_SEGMENT_MODE == XCP_ON 509 Xcp_SetSegmentMode_Res,
511 Xcp_CommandNotImplemented_Res,
513 #if XCP_ENABLE_GET_SEGMENT_MODE == XCP_ON 514 Xcp_GetSegmentMode_Res,
516 Xcp_CommandNotImplemented_Res,
518 #if XCP_ENABLE_COPY_CAL_PAGE == XCP_ON 521 Xcp_CommandNotImplemented_Res,
524 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
525 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
526 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
527 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
530 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 531 Xcp_ClearDaqList_Res,
534 Xcp_SetDaqListMode_Res,
535 Xcp_GetDaqListMode_Res,
536 Xcp_StartStopDaqList_Res,
537 Xcp_StartStopSynch_Res,
538 #if XCP_ENABLE_GET_DAQ_CLOCK == XCP_ON 541 Xcp_CommandNotImplemented_Res,
543 #if XCP_ENABLE_READ_DAQ == XCP_ON 546 Xcp_CommandNotImplemented_Res,
548 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON 549 Xcp_GetDaqProcessorInfo_Res,
551 Xcp_CommandNotImplemented_Res,
553 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON 554 Xcp_GetDaqResolutionInfo_Res,
556 Xcp_CommandNotImplemented_Res,
558 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON 559 Xcp_GetDaqListInfo_Res,
561 Xcp_CommandNotImplemented_Res,
563 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON 564 Xcp_GetDaqEventInfo_Res,
566 Xcp_CommandNotImplemented_Res,
568 #if XCP_ENABLE_FREE_DAQ == XCP_ON 571 Xcp_CommandNotImplemented_Res,
573 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON 576 Xcp_CommandNotImplemented_Res,
578 #if XCP_ENABLE_ALLOC_ODT == XCP_ON 581 Xcp_CommandNotImplemented_Res,
583 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON 584 Xcp_AllocOdtEntry_Res,
586 Xcp_CommandNotImplemented_Res,
589 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
590 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
591 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
592 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
593 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
594 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
595 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
596 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
597 Xcp_CommandNotImplemented_Res,
600 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 601 Xcp_ProgramStart_Res,
602 Xcp_ProgramClear_Res,
604 Xcp_ProgramReset_Res,
605 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON 606 Xcp_GetPgmProcessorInfo_Res,
608 Xcp_CommandNotImplemented_Res,
610 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON 611 Xcp_GetSectorInfo_Res,
613 Xcp_CommandNotImplemented_Res,
615 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON 616 Xcp_ProgramPrepare_Res,
618 Xcp_CommandNotImplemented_Res,
620 #if XCP_ENABLE_PROGRAM_FORMAT == XCP_ON 621 Xcp_ProgramFormat_Res,
623 Xcp_CommandNotImplemented_Res,
625 #if XCP_ENABLE_PROGRAM_NEXT == XCP_ON 628 Xcp_CommandNotImplemented_Res,
630 #if XCP_ENABLE_PROGRAM_MAX == XCP_ON 633 Xcp_CommandNotImplemented_Res,
635 #if XCP_ENABLE_PROGRAM_VERIFY == XCP_ON 636 Xcp_ProgramVerify_Res,
638 Xcp_CommandNotImplemented_Res,
641 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
642 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
643 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
644 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
645 Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
646 Xcp_CommandNotImplemented_Res,
648 #if (XCP_ENABLE_DAQ_COMMANDS == XCP_ON) && \ 649 (XCP_ENABLE_WRITE_DAQ_MULTIPLE == XCP_ON) 650 Xcp_WriteDaqMultiple_Res,
652 Xcp_CommandNotImplemented_Res,
660 void Xcp_Init(
void) {
661 Xcp_ConnectionState = XCP_DISCONNECTED;
664 XcpUtl_MemSet(&Xcp_State, UINT8(0), (uint32_t)
sizeof(Xcp_StateType));
665 Xcp_State.busy = (bool)XCP_FALSE;
667 Xcp_DefaultResourceProtection();
669 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON 670 Xcp_State.slaveBlockModeState.blockTransferActive = (bool)XCP_FALSE;
671 Xcp_State.slaveBlockModeState.remaining = UINT8(0);
673 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON 674 Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_FALSE;
675 Xcp_State.masterBlockModeState.remaining = UINT8(0);
677 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 679 Xcp_State.daqProcessor.state = XCP_DAQ_STATE_STOPPED;
680 XcpDaq_SetPointer(0, 0, 0);
682 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 683 Xcp_State.pgmProcessor.state = XCP_PGM_STATE_UNINIT;
685 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE != 0 686 Xcp_State.counter = (uint16_t)0;
689 #if XCP_ENABLE_STATISTICS == XCP_ON 690 Xcp_State.statistics.crosBusy = UINT32(0);
691 Xcp_State.statistics.crosSend = UINT32(0);
692 Xcp_State.statistics.ctosReceived = UINT32(0);
696 #if (XCP_ENABLE_BUILD_CHECKSUM == XCP_ON) && \ 697 (XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_ON) 702 XCP_STATIC
void Xcp_DefaultResourceProtection(
void) {
703 #if XCP_ENABLE_RESOURCE_PROTECTION == XCP_ON 704 Xcp_State.resourceProtection = UINT8(0);
705 Xcp_State.seedRequested = UINT8(0);
706 #if (XCP_PROTECT_CAL == XCP_ON) || (XCP_PROTECT_PAG == XCP_ON) 707 Xcp_State.resourceProtection |= XCP_RESOURCE_CAL_PAG;
709 #if XCP_PROTECT_DAQ == XCP_ON 710 Xcp_State.resourceProtection |= XCP_RESOURCE_DAQ;
712 #if XCP_PROTECT_STIM == XCP_ON 713 Xcp_State.resourceProtection |= XCP_RESOURCE_STIM;
715 #if XCP_PROTECT_PGM == XCP_ON 716 Xcp_State.resourceProtection |= XCP_RESOURCE_PGM;
721 void Xcp_Disconnect(
void) {
722 XcpTl_ReleaseConnection();
723 Xcp_DefaultResourceProtection();
724 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 729 void Xcp_MainFunction(
void) {
730 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON 731 if (Xcp_SlaveBlockTransferIsActive) {
732 Xcp_UploadSingleBlock();
736 #if (XCP_ENABLE_BUILD_CHECKSUM == XCP_ON) && \ 737 (XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_ON) 738 Xcp_ChecksumMainFunction();
741 XcpHw_Sleep(XCP_MAIN_FUNCTION_PERIOD);
744 void Xcp_SetMta(Xcp_MtaType mta) { Xcp_State.mta = mta; }
746 Xcp_MtaType Xcp_GetNonPagedAddress(
void const *
const ptr) {
749 mta.ext = (uint8_t)0;
750 mta.address = (Xcp_PointerSizeType)ptr;
754 void Xcp_SendCto(
void) {
755 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE != 0 756 const uint16_t len = Xcp_CtoOut.len;
759 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE == 1 760 Xcp_CtoOut.data[0] = XCP_LOBYTE(len);
761 #elif XCP_TRANSPORT_LAYER_LENGTH_SIZE == 2 762 Xcp_CtoOut.data[0] = XCP_LOBYTE(len);
763 Xcp_CtoOut.data[1] = XCP_HIBYTE(len);
766 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE == 1 767 Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
768 XCP_LOBYTE(Xcp_State.counter);
770 #elif XCP_TRANSPORT_LAYER_COUNTER_SIZE == 2 771 Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
772 XCP_LOBYTE(Xcp_State.counter);
773 Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE + 1] =
774 XCP_HIBYTE(Xcp_State.counter);
778 #if XCP_ENABLE_STATISTICS == XCP_ON 779 Xcp_State.statistics.crosSend++;
782 XcpTl_Send(Xcp_CtoOut.data,
783 Xcp_CtoOut.len + (uint16_t)XCP_TRANSPORT_LAYER_BUFFER_OFFSET);
786 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 788 void Xcp_SendDto(
void) {
789 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE != 0 790 const uint16_t len = Xcp_DtoOut.len;
793 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE == 1 794 Xcp_DtoOut.data[0] = XCP_LOBYTE(len);
795 #elif XCP_TRANSPORT_LAYER_LENGTH_SIZE == 2 796 Xcp_DtoOut.data[0] = XCP_LOBYTE(len);
797 Xcp_DtoOut.data[1] = XCP_HIBYTE(len);
800 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE == 1 801 Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
802 XCP_LOBYTE(Xcp_State.counter);
804 #elif XCP_TRANSPORT_LAYER_COUNTER_SIZE == 2 805 Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
806 XCP_LOBYTE(Xcp_State.counter);
807 Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE + 1] =
808 XCP_HIBYTE(Xcp_State.counter);
812 #if XCP_ENABLE_STATISTICS == XCP_ON 813 Xcp_State.statistics.crosSend++;
816 XcpTl_Send(Xcp_DtoOut.data,
817 Xcp_DtoOut.len + (uint16_t)XCP_TRANSPORT_LAYER_BUFFER_OFFSET);
820 uint8_t *Xcp_GetDtoOutPtr(
void) {
821 return &(Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_BUFFER_OFFSET]);
824 void Xcp_SetDtoOutLen(uint16_t len) { Xcp_DtoOut.len = len; }
828 uint8_t *Xcp_GetCtoOutPtr(
void) {
829 return &(Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_BUFFER_OFFSET]);
832 void Xcp_SetCtoOutLen(uint16_t len) { Xcp_CtoOut.len = len; }
834 void Xcp_Send8(uint8_t len, uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3,
835 uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7) {
836 uint8_t *dataOut = Xcp_GetCtoOutPtr();
838 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON 842 Xcp_SetCtoOutLen(UINT16(len));
885 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON 886 XCP_STATIC
bool Xcp_SlaveBlockTransferIsActive(
void) {
887 return Xcp_State.slaveBlockModeState.blockTransferActive;
890 XCP_STATIC
void Xcp_SlaveBlockTransferSetActive(
bool onOff) {
891 XCP_ENTER_CRITICAL();
894 Xcp_State.slaveBlockModeState.blockTransferActive = onOff;
895 XCP_LEAVE_CRITICAL();
898 void Xcp_UploadSingleBlock(
void) {
899 uint8_t *dataOut = XCP_NULL;
900 uint8_t length = UINT8(0x00);
901 Xcp_MtaType dst = {0};
903 if (!Xcp_SlaveBlockTransferIsActive()) {
906 dataOut = Xcp_GetCtoOutPtr();
907 dataOut[0] = (uint8_t)ERR_SUCCESS;
908 dst.address = (Xcp_PointerSizeType)(dataOut + 1);
909 dst.ext = (uint8_t)0;
911 if (Xcp_State.slaveBlockModeState.remaining <= (XCP_MAX_CTO - 1)) {
912 length = Xcp_State.slaveBlockModeState.remaining;
914 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON 915 Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
917 Xcp_SetCtoOutLen(length + UINT16(1));
921 Xcp_CopyMemory(dst, Xcp_State.mta, (uint32_t)length);
922 XCP_INCREMENT_MTA(length);
923 Xcp_State.slaveBlockModeState.remaining -= length;
925 Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
927 Xcp_CopyMemory(dst, Xcp_State.mta, (uint32_t)(XCP_MAX_CTO - 1));
928 XCP_INCREMENT_MTA((XCP_MAX_CTO - 1));
929 Xcp_State.slaveBlockModeState.remaining -= (XCP_MAX_CTO - 1);
933 if (Xcp_State.slaveBlockModeState.remaining == UINT8(0)) {
934 Xcp_SlaveBlockTransferSetActive((
bool)XCP_FALSE);
941 XCP_STATIC
void Xcp_Upload(uint8_t len) {
942 uint8_t *dataOut = Xcp_GetCtoOutPtr();
943 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_OFF 944 Xcp_MtaType dst = {0};
945 dataOut[0] = (uint8_t)ERR_SUCCESS;
946 dst.address = (uint32_t)(dataOut + 1);
947 dst.ext = (uint8_t)0;
949 Xcp_CopyMemory(dst, Xcp_State.mta, (uint32_t)len);
950 XCP_INCREMENT_MTA(len);
951 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON 952 Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
954 Xcp_SetCtoOutLen(len + UINT16(1));
958 Xcp_State.slaveBlockModeState.remaining = len;
961 Xcp_SlaveBlockTransferSetActive((
bool)XCP_TRUE);
962 Xcp_UploadSingleBlock();
972 void Xcp_DispatchCommand(Xcp_PduType
const *
const pdu) {
973 const uint8_t cmd = pdu->data[0];
976 if (Xcp_State.connected == (
bool)XCP_TRUE) {
983 #if XCP_ENABLE_STATISTICS == XCP_ON 984 Xcp_State.statistics.ctosReceived++;
986 Xcp_ServerCommands[UINT8(0xff) - cmd](pdu);
989 #if XCP_ENABLE_STATISTICS == XCP_ON 990 Xcp_State.statistics.ctosReceived++;
992 if (pdu->data[0] == UINT8(XCP_CONNECT)) {
993 Xcp_Connect_Res(pdu);
997 #if defined(_MSC_VER) 1002 void Xcp_SetSendCallout(Xcp_SendCalloutType callout) {
1003 Xcp_SendCallout = callout;
1013 Xcp_ConnectionStateType Xcp_GetConnectionState(
void) {
1014 return Xcp_ConnectionState;
1022 XCP_STATIC
void Xcp_CommandNotImplemented_Res(Xcp_PduType
const *
const pdu) {
1023 DBG_TRACE2(
"Command not implemented [%02X].\n\r", pdu->data[0]);
1024 Xcp_ErrorResponse(UINT8(ERR_CMD_UNKNOWN));
1027 XCP_STATIC
void Xcp_Connect_Res(Xcp_PduType
const *
const pdu) {
1028 uint8_t resource = UINT8(0x00);
1029 uint8_t commModeBasic = UINT8(0x00);
1031 DBG_TRACE1(
"CONNECT\n\r");
1033 if (Xcp_State.connected == (
bool)XCP_FALSE) {
1034 Xcp_State.connected = (bool)XCP_TRUE;
1038 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 1039 resource |= XCP_RESOURCE_PGM;
1041 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 1042 resource |= XCP_RESOURCE_DAQ;
1044 #if (XCP_ENABLE_CAL_COMMANDS == XCP_ON) || (XCP_ENABLE_PAG_COMMANDS == XCP_ON) 1045 resource |= XCP_RESOURCE_CAL_PAG;
1047 #if XCP_ENABLE_STIM == XCP_ON 1048 resource |= XCP_RESOURCE_STIM;
1051 commModeBasic |= XCP_BYTE_ORDER;
1052 commModeBasic |= XCP_ADDRESS_GRANULARITY;
1053 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON 1054 commModeBasic |= XCP_SLAVE_BLOCK_MODE;
1056 #if XCP_ENABLE_GET_COMM_MODE_INFO 1057 commModeBasic |= XCP_OPTIONAL_COMM_MODE;
1060 XcpTl_SaveConnection();
1062 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(resource),
1063 UINT8(commModeBasic), UINT8(XCP_MAX_CTO), XCP_LOBYTE(XCP_MAX_DTO),
1064 XCP_HIBYTE(XCP_MAX_DTO), UINT8(XCP_PROTOCOL_VERSION_MAJOR),
1065 UINT8(XCP_TRANSPORT_LAYER_VERSION_MAJOR));
1070 XCP_STATIC
void Xcp_Disconnect_Res(Xcp_PduType
const *
const pdu) {
1071 DBG_TRACE1(
"DISCONNECT\n\r\n\r");
1073 XCP_ASSERT_PGM_IDLE();
1074 Xcp_PositiveResponse();
1078 XCP_STATIC
void Xcp_GetStatus_Res(Xcp_PduType
const *
const pdu) {
1079 DBG_TRACE1(
"GET_STATUS\n\r");
1082 UINT8(6), UINT8(XCP_PACKET_IDENTIFIER_RES),
1084 #
if XCP_ENABLE_RESOURCE_PROTECTION == XCP_ON
1085 Xcp_State.resourceProtection,
1092 UINT8(0), UINT8(0));
1095 XCP_STATIC
void Xcp_Synch_Res(Xcp_PduType
const *
const pdu) {
1096 DBG_TRACE1(
"SYNCH\n\r");
1097 Xcp_ErrorResponse(UINT8(ERR_CMD_SYNCH));
1100 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON 1102 XCP_STATIC
void Xcp_GetCommModeInfo_Res(Xcp_PduType
const *
const pdu) {
1103 uint8_t commModeOptional = UINT8(0);
1105 DBG_TRACE1(
"GET_COMM_MODE_INFO\n\r");
1107 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON 1108 commModeOptional |= XCP_MASTER_BLOCK_MODE;
1111 #if XCP_ENABLE_INTERLEAVED_MODE == XCP_ON 1112 commModeOptional |= XCP_INTERLEAVED_MODE;
1115 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0),
1116 commModeOptional, UINT8(0),
1117 UINT8(XCP_MAX_BS), UINT8(XCP_MIN_ST), UINT8(XCP_QUEUE_SIZE),
1118 UINT8(XCP_DRIVER_VERSION));
1123 #if XCP_ENABLE_GET_ID == XCP_ON 1125 XCP_STATIC
void Xcp_GetId_Res(Xcp_PduType
const *
const pdu) {
1126 uint8_t idType = Xcp_GetByte(pdu, UINT8(1));
1127 static uint8_t
const *response = XCP_NULL;
1128 uint32_t response_len = UINT32(0);
1129 bool valid = XCP_TRUE;
1131 DBG_TRACE2(
"GET_ID [type: 0x%02x]\n\r", idType);
1133 if (idType == UINT8(0)) {
1134 response = Xcp_GetId0.name;
1135 response_len = Xcp_GetId0.len;
1136 }
else if (idType == UINT8(1)) {
1137 response = Xcp_GetId1.name;
1138 response_len = Xcp_GetId1.len;
1140 #if XCP_ENABLE_GET_ID_HOOK == XCP_ON 1142 if (!Xcp_HookFunction_GetId(idType, &response, &response_len)) {
1154 Xcp_SetMta(Xcp_GetNonPagedAddress(response));
1156 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0), UINT8(0),
1157 UINT8(0), XCP_LOBYTE(XCP_LOWORD(response_len)),
1158 XCP_HIBYTE(XCP_LOWORD(response_len)),
1159 XCP_LOBYTE(XCP_HIWORD(response_len)),
1160 XCP_HIBYTE(XCP_HIWORD(response_len)));
1165 #if XCP_ENABLE_GET_SEED == XCP_ON 1166 XCP_STATIC
void Xcp_GetSeed_Res(Xcp_PduType
const *
const pdu) {
1167 uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
1168 uint8_t resource = Xcp_GetByte(pdu, UINT8(2));
1169 Xcp_1DArrayType seed = {0};
1170 uint8_t length = UINT8(0);
1171 uint8_t *dataOut = Xcp_GetCtoOutPtr();
1173 DBG_TRACE3(
"GET_SEED [mode: %02x resource: %02x]\n\r", mode, resource);
1175 XCP_ASSERT_PGM_IDLE();
1177 case XCP_RESOURCE_PGM:
1178 #if XCP_ENABLE_PGM_COMMANDS == XCP_OFF 1179 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1184 case XCP_RESOURCE_STIM:
1185 #if XCP_ENABLE_STIM == XCP_OFF 1186 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1191 case XCP_RESOURCE_DAQ:
1192 #if XCP_ENABLE_DAQ_COMMANDS == XCP_OFF 1193 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1198 case XCP_RESOURCE_CAL_PAG:
1199 #if (XCP_ENABLE_CAL_COMMANDS == XCP_OFF) && (XCP_ENABLE_PAG_COMMANDS == XCP_OFF) 1200 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1206 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1210 if (Xcp_IsProtected(resource)) {
1211 Xcp_HookFunction_GetSeed(resource, &seed);
1212 length = XCP_MIN(XCP_MAX_CTO - UINT16(2), seed.length);
1213 XCP_ASSERT_LE(length, XCP_TRANSPORT_LAYER_CTO_BUFFER_SIZE - 2);
1214 XcpUtl_MemCopy(dataOut + UINT16(2), seed.data, (uint32_t)length);
1219 Xcp_State.seedRequested |= resource;
1220 dataOut[0] = UINT8(ERR_SUCCESS);
1221 dataOut[1] = length;
1222 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON 1223 Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
1225 Xcp_SetCtoOutLen(length + UINT16(2));
1231 #if XCP_ENABLE_UNLOCK == XCP_ON 1232 XCP_STATIC
void Xcp_Unlock_Res(Xcp_PduType
const *
const pdu) {
1233 uint8_t length = Xcp_GetByte(pdu, UINT8(1));
1234 Xcp_1DArrayType key = {0};
1236 DBG_TRACE2(
"UNLOCK [length: %u]\n\r", length);
1238 XCP_ASSERT_PGM_IDLE();
1239 if (Xcp_State.seedRequested == UINT8(0)) {
1240 Xcp_ErrorResponse(UINT8(ERR_SEQUENCE));
1244 key.length = length;
1245 key.data = pdu->data + 2;
1247 if (Xcp_HookFunction_Unlock(Xcp_State.seedRequested,
1249 Xcp_State.resourceProtection &=
1250 UINT8(~(Xcp_State.seedRequested));
1252 UINT8(2), UINT8(XCP_PACKET_IDENTIFIER_RES),
1253 Xcp_State.resourceProtection,
1254 UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
1257 Xcp_ErrorResponse(UINT8(ERR_ACCESS_LOCKED));
1260 Xcp_State.seedRequested = UINT8(0x00);
1264 #if XCP_ENABLE_UPLOAD == XCP_ON 1266 XCP_STATIC
void Xcp_Upload_Res(Xcp_PduType
const *
const pdu) {
1267 uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1269 DBG_TRACE2(
"UPLOAD [len: %u]\n\r", len);
1271 XCP_ASSERT_PGM_IDLE();
1272 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_READ, XCP_FALSE);
1273 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_OFF 1274 if (len > UINT8(XCP_MAX_CTO - 1)) {
1275 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1287 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON 1289 XCP_STATIC
void Xcp_ShortUpload_Res(Xcp_PduType
const *
const pdu) {
1290 uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1292 DBG_TRACE2(
"SHORT-UPLOAD [len: %u]\n\r", len);
1294 XCP_ASSERT_PGM_IDLE();
1295 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_READ,
1297 if (len > UINT8(XCP_MAX_CTO - 1)) {
1298 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1302 Xcp_State.mta.ext = Xcp_GetByte(pdu, UINT8(3));
1303 Xcp_State.mta.address = Xcp_GetDWord(pdu, UINT8(4));
1309 #if XCP_ENABLE_SET_MTA == XCP_ON 1311 XCP_STATIC
void Xcp_SetMta_Res(Xcp_PduType
const *
const pdu) {
1312 Xcp_State.mta.ext = Xcp_GetByte(pdu, UINT8(3));
1313 Xcp_State.mta.address = Xcp_GetDWord(pdu, UINT8(4));
1315 DBG_TRACE3(
"SET_MTA [address: 0x%08x ext: 0x%02x]\n\r", Xcp_State.mta.address,
1318 Xcp_PositiveResponse();
1323 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON 1325 void Xcp_SendChecksumPositiveResponse(Xcp_ChecksumType checksum) {
1326 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES),
1327 UINT8(XCP_CHECKSUM_METHOD), UINT8(0), UINT8(0),
1328 XCP_LOBYTE(XCP_LOWORD(checksum)), XCP_HIBYTE(XCP_LOWORD(checksum)),
1329 XCP_LOBYTE(XCP_HIWORD(checksum)), XCP_HIBYTE(XCP_HIWORD(checksum)));
1332 void Xcp_SendChecksumOutOfRangeResponse(
void) {
1333 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_ERR), UINT8(ERR_OUT_OF_RANGE),
1335 XCP_LOBYTE(XCP_LOWORD(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)),
1336 XCP_HIBYTE(XCP_LOWORD(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)),
1337 XCP_LOBYTE(XCP_HIWORD(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)),
1338 XCP_HIBYTE(XCP_HIWORD(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)));
1341 XCP_STATIC
void Xcp_BuildChecksum_Res(Xcp_PduType
const *
const pdu) {
1342 uint32_t blockSize = Xcp_GetDWord(pdu, UINT8(4));
1343 Xcp_ChecksumType checksum = (Xcp_ChecksumType)0;
1344 uint8_t
const *ptr = XCP_NULL;
1346 DBG_TRACE2(
"BUILD_CHECKSUM [blocksize: %u]\n\r", blockSize);
1348 XCP_ASSERT_PGM_IDLE();
1349 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, blockSize, XCP_MEM_ACCESS_READ,
1351 #if XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE > 0 1353 if (blockSize > UINT32(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)) {
1354 Xcp_SendChecksumOutOfRangeResponse();
1359 ptr = (uint8_t
const *)Xcp_State.mta.address;
1362 #
if XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_OFF
1364 Xcp_CalculateChecksum(ptr, blockSize, (Xcp_ChecksumType)0, XCP_TRUE);
1365 Xcp_SendChecksumPositiveResponse(checksum);
1367 if (blockSize <= UINT32(XCP_CHECKSUM_CHUNK_SIZE)) {
1368 checksum = Xcp_CalculateChecksum(ptr, blockSize, (Xcp_ChecksumType)0,
1370 Xcp_SendChecksumPositiveResponse(checksum);
1372 Xcp_StartChecksumCalculation(ptr, blockSize);
1381 Callout der die gültigkeit eines Speicherzugriffs überprüft [addr;length]
1384 #if XCP_ENABLE_TRANSPORT_LAYER_CMD 1385 XCP_STATIC
void Xcp_TransportLayerCmd_Res(Xcp_PduType
const *
const pdu) {
1386 XCP_ASSERT_PGM_IDLE();
1387 XcpTl_TransportLayerCmd_Res(pdu);
1391 #if XCP_ENABLE_USER_CMD 1392 XCP_STATIC
void Xcp_UserCmd_Res(Xcp_PduType
const *
const pdu) {
1393 XCP_ASSERT_PGM_IDLE();
1402 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON 1404 XCP_STATIC
void Xcp_Download_Res(Xcp_PduType
const *
const pdu) {
1405 uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1406 const uint16_t LIMIT = XCP_MAX_BS * XCP_DOWNLOAD_PAYLOAD_LENGTH;
1407 DBG_TRACE2(
"DOWNLOAD [len: %u]\n\r", len);
1409 XCP_ASSERT_PGM_IDLE();
1410 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_WRITE, XCP_FALSE);
1412 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON 1413 Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_FALSE;
1415 Xcp_ErrorResponse(ERR_OUT_OF_RANGE);
1417 }
else if (len > XCP_DOWNLOAD_PAYLOAD_LENGTH) {
1419 Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_TRUE;
1420 Xcp_State.masterBlockModeState.remaining =
1421 len - XCP_DOWNLOAD_PAYLOAD_LENGTH;
1422 Xcp_Download_Copy(UINT32(pdu->data + 2), UINT8(0),
1423 UINT32(XCP_DOWNLOAD_PAYLOAD_LENGTH));
1428 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_OFF 1429 if (len > XCP_DOWNLOAD_PAYLOAD_LENGTH) {
1435 Xcp_Download_Copy(UINT32(pdu->data + 2), UINT8(0), UINT32(len));
1436 Xcp_PositiveResponse();
1439 #if XCP_ENABLE_DOWNLOAD_NEXT == XCP_ON 1440 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON 1441 XCP_STATIC
void Xcp_DownloadNext_Res(Xcp_PduType
const *
const pdu) {
1442 uint8_t remaining = Xcp_GetByte(pdu, UINT8(1));
1444 Xcp_MtaType src = {0};
1446 DBG_TRACE2(
"DOWNLOAD_NEXT [remaining: %u]\n\r", remaining);
1448 XCP_ASSERT_PGM_IDLE();
1449 if (!Xcp_State.masterBlockModeState.blockTransferActive) {
1455 len = XCP_MIN(remaining, XCP_DOWNLOAD_PAYLOAD_LENGTH);
1456 Xcp_Download_Copy(UINT32(pdu->data + 2), UINT8(0), UINT32(len));
1457 Xcp_State.masterBlockModeState.remaining -= len;
1458 if (Xcp_State.masterBlockModeState.remaining == UINT8(0)) {
1459 Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_FALSE;
1460 Xcp_PositiveResponse();
1466 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON 1468 XCP_STATIC
void Xcp_DownloadMax_Res(Xcp_PduType
const *
const pdu) {
1469 Xcp_MtaType src = {0};
1471 DBG_TRACE1(
"DOWNLOAD_MAX\n\r");
1473 XCP_ASSERT_PGM_IDLE();
1474 Xcp_Download_Copy(UINT32(pdu->data + 1), UINT8(0),
1475 UINT32(XCP_DOWNLOAD_PAYLOAD_LENGTH + 1));
1476 Xcp_PositiveResponse();
1481 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON 1483 XCP_STATIC
void Xcp_ShortDownload_Res(Xcp_PduType
const *
const pdu) {
1484 uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1485 uint8_t addrExt = Xcp_GetByte(pdu, UINT8(3));
1486 uint32_t address = Xcp_GetDWord(pdu, UINT8(4));
1487 Xcp_MtaType src = {0};
1488 Xcp_MtaType dst = {0};
1490 DBG_TRACE4(
"SHORT-DOWNLOAD [len: %u address: 0x%08x ext: 0x%02x]\n\r", len,
1492 dst.address = address;
1495 XCP_ASSERT_PGM_IDLE();
1496 XCP_CHECK_MEMORY_ACCESS(dst, len, XCP_MEM_ACCESS_WRITE, (
bool)XCP_FALSE);
1497 if (len > (XCP_MAX_CTO - UINT8(8))) {
1498 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1502 src.address = (Xcp_PointerSizeType)pdu->data + 8;
1504 Xcp_CopyMemory(dst, src, (uint32_t)len);
1506 XCP_INCREMENT_MTA(len);
1508 Xcp_PositiveResponse();
1513 #if XCP_ENABLE_MODIFY_BITS == XCP_ON 1515 XCP_STATIC
void Xcp_ModifyBits_Res(Xcp_PduType
const *
const pdu) {
1516 uint8_t shiftValue = Xcp_GetByte(pdu, UINT8(1));
1517 uint16_t andMask = Xcp_GetWord(pdu, UINT8(2));
1518 uint16_t xorMask = Xcp_GetWord(pdu, UINT8(4));
1519 uint32_t *vp = XCP_NULL;
1521 DBG_TRACE4(
"MODIFY-BITS [shiftValue: 0x%02X andMask: 0x%04x ext: xorMask: " 1523 shiftValue, andMask, xorMask);
1524 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, 2, XCP_MEM_ACCESS_WRITE,
1526 vp = (uint32_t *)Xcp_State.mta.address;
1527 *vp = ((*vp) & ((~((uint32_t)(((uint16_t)~andMask) << shiftValue))) ^
1528 ((uint32_t)(xorMask << shiftValue))));
1530 Xcp_PositiveResponse();
1542 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 1544 XCP_STATIC
void Xcp_ClearDaqList_Res(Xcp_PduType
const *
const pdu) {
1545 XcpDaq_ListIntegerType daqListNumber = (XcpDaq_ListIntegerType)0;
1547 daqListNumber = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1549 DBG_TRACE2(
"CLEAR_DAQ_LIST [daq: %u] \n\r", daqListNumber);
1551 XCP_ASSERT_PGM_IDLE();
1552 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1553 Xcp_PositiveResponse();
1556 XCP_STATIC
void Xcp_SetDaqPtr_Res(Xcp_PduType
const *
const pdu) {
1557 XcpDaq_ListIntegerType daqList = (XcpDaq_ListIntegerType)0;
1558 XcpDaq_ODTIntegerType odt = (XcpDaq_ODTIntegerType)0;
1559 XcpDaq_ODTEntryIntegerType odtEntry = (XcpDaq_ODTEntryIntegerType)0;
1561 XCP_ASSERT_DAQ_STOPPED();
1562 XCP_ASSERT_PGM_IDLE();
1563 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1564 daqList = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1565 odt = Xcp_GetByte(pdu, UINT8(4));
1566 odtEntry = Xcp_GetByte(pdu, UINT8(5));
1570 if (!XcpDaq_ValidateOdtEntry(daqList, odt, odtEntry)) {
1573 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1577 XcpDaq_SetPointer(daqList, odt, odtEntry);
1579 DBG_TRACE4(
"SET_DAQ_PTR [daq: %u odt: %u odtEntry: %u]\n\r",
1580 Xcp_State.daqPointer.daqList, Xcp_State.daqPointer.odt,
1581 Xcp_State.daqPointer.odtEntry);
1583 Xcp_PositiveResponse();
1586 XCP_STATIC
void Xcp_WriteDaq_Res(Xcp_PduType
const *
const pdu) {
1587 const uint8_t bitOffset = Xcp_GetByte(pdu, UINT8(1));
1588 const uint8_t elemSize = Xcp_GetByte(pdu, UINT8(2));
1589 const uint8_t adddrExt = Xcp_GetByte(pdu, UINT8(3));
1590 const uint32_t address = Xcp_GetDWord(pdu, UINT8(4));
1592 DBG_TRACE1(
"WRITE_DAQ\n\r");
1594 XCP_ASSERT_DAQ_STOPPED();
1595 XCP_ASSERT_PGM_IDLE();
1596 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1597 #if XCP_DAQ_ENABLE_PREDEFINED_LISTS == XCP_ON 1599 if (Xcp_State.daqPointer.daqList < XcpDaq_PredefinedListCount) {
1600 Xcp_SendResult(ERR_WRITE_PROTECTED);
1604 Xcp_WriteDaqEntry(bitOffset, elemSize, adddrExt, address);
1605 Xcp_PositiveResponse();
1608 #if XCP_ENABLE_WRITE_DAQ_MULTIPLE == XCP_ON 1609 XCP_STATIC
void Xcp_WriteDaqMultiple_Res(Xcp_PduType
const *
const pdu) {
1610 uint8_t numElements = Xcp_GetByte(pdu, UINT8(1));
1611 uint8_t bitOffset = UINT8(0);
1612 uint8_t elemSize = UINT8(0);
1613 uint8_t adddrExt = UINT8(0);
1614 uint32_t address = UINT32(0);
1615 uint8_t daq_offset = UINT8(0);
1616 uint8_t idx = UINT8(0);
1618 if (((numElements * UINT8(8)) + UINT8(2)) > XCP_MAX_CTO) {
1620 Xcp_SendResult(ERR_OUT_OF_RANGE);
1623 DBG_TRACE2(
"WRITE_DAQ_MULTIPLE [numElements: 0x%08x]\n\r", numElements);
1624 XCP_ASSERT_DAQ_STOPPED();
1625 XCP_ASSERT_PGM_IDLE();
1626 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1627 #if XCP_DAQ_ENABLE_PREDEFINED_LISTS == XCP_ON 1629 if (Xcp_State.daqPointer.daqList < XcpDaq_PredefinedListCount) {
1630 Xcp_SendResult(ERR_WRITE_PROTECTED);
1634 for (idx = UINT8(0); idx < numElements; ++idx) {
1635 daq_offset = (idx * UINT8(8)) + UINT8(2);
1636 bitOffset = Xcp_GetByte(pdu, daq_offset + UINT8(0));
1637 elemSize = Xcp_GetByte(pdu, daq_offset + UINT8(1));
1638 address = Xcp_GetDWord(pdu, daq_offset + UINT8(2));
1639 adddrExt = Xcp_GetByte(pdu, daq_offset + UINT8(6));
1640 Xcp_WriteDaqEntry(bitOffset, elemSize, adddrExt, address);
1642 Xcp_PositiveResponse();
1644 #endif // XCP_ENABLE_WRITE_DAQ_MULTIPLE 1646 XCP_STATIC
void Xcp_SetDaqListMode_Res(Xcp_PduType
const *
const pdu) {
1647 XcpDaq_ListStateType *entry = XCP_NULL;
1648 const uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
1649 const XcpDaq_ListIntegerType daqListNumber =
1650 (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1651 const uint16_t eventChannelNumber = Xcp_GetWord(pdu, UINT8(4));
1652 const uint8_t prescaler = Xcp_GetByte(pdu, UINT8(6));
1653 const uint8_t priority = Xcp_GetByte(pdu, UINT8(7));
1655 DBG_TRACE6(
"SET_DAQ_LIST_MODE [mode: 0x%02x daq: %03u event: %03u prescaler: " 1656 "%03u priority: %03u]\n\r",
1657 mode, daqListNumber, eventChannelNumber, prescaler, priority);
1658 XCP_ASSERT_DAQ_STOPPED();
1659 XCP_ASSERT_PGM_IDLE();
1660 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1662 #if XCP_ENABLE_STIM == XCP_OFF 1663 if ((mode & XCP_DAQ_LIST_MODE_DIRECTION) == XCP_DAQ_LIST_MODE_DIRECTION) {
1664 Xcp_ErrorResponse(UINT8(ERR_CMD_SYNTAX));
1672 #if XCP_DAQ_ALTERNATING_SUPPORTED == XCP_OFF 1673 if ((mode & XCP_DAQ_LIST_MODE_ALTERNATING) == XCP_DAQ_LIST_MODE_ALTERNATING) {
1674 Xcp_ErrorResponse(UINT8(ERR_CMD_SYNTAX));
1678 #if XCP_DAQ_PRIORITIZATION_SUPPORTED == XCP_OFF 1680 if (priority > UINT8(0)) {
1681 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1685 #if XCP_DAQ_PRESCALER_SUPPORTED == XCP_OFF 1687 if (prescaler > UINT8(1)) {
1688 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1693 entry = XcpDaq_GetListState(daqListNumber);
1694 XcpDaq_AddEventChannel(daqListNumber, eventChannelNumber);
1697 Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_TIMESTAMP);
1699 Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_ALTERNATING);
1701 Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_DIRECTION);
1702 entry->mode = Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_PID_OFF);
1703 entry->mode = Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_SELECTED);
1704 entry->mode = Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_STARTED);
1705 #if XCP_DAQ_ENABLE_PRESCALER == XCP_ON 1706 entry->prescaler = prescaler;
1709 Xcp_PositiveResponse();
1712 XCP_STATIC
void Xcp_StartStopDaqList_Res(Xcp_PduType
const *
const pdu) {
1713 XcpDaq_ListStateType *entry = XCP_NULL;
1714 const uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
1715 XcpDaq_ODTIntegerType firstPid = (XcpDaq_ODTIntegerType)0;
1716 const XcpDaq_ListIntegerType daqListNumber =
1717 (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1719 DBG_TRACE3(
"START_STOP_DAQ_LIST [mode: 0x%02x daq: %03u]\n\r", mode,
1721 XCP_ASSERT_PGM_IDLE();
1722 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1724 if (daqListNumber >= XcpDaq_GetListCount()) {
1725 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1728 entry = XcpDaq_GetListState(daqListNumber);
1730 if (mode == UINT8(0)) {
1731 }
else if (mode == UINT8(1)) {
1732 }
else if (mode == UINT8(2)) {
1733 entry->mode |= XCP_DAQ_LIST_MODE_SELECTED;
1735 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1739 XcpDaq_GetFirstPid(daqListNumber, &firstPid);
1741 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), firstPid, UINT8(0),
1742 UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
1745 XCP_STATIC
void Xcp_StartStopSynch_Res(Xcp_PduType
const *
const pdu) {
1746 const uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
1748 DBG_TRACE2(
"START_STOP_SYNCH [mode: 0x%02x]\n\r", mode);
1749 XCP_ASSERT_PGM_IDLE();
1750 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1752 if (mode == START_SELECTED) {
1753 XcpDaq_StartSelectedLists();
1754 XcpDaq_SetProcessorState(XCP_DAQ_STATE_RUNNING);
1755 }
else if (mode == STOP_ALL) {
1756 XcpDaq_StopAllLists();
1757 XcpDaq_SetProcessorState(XCP_DAQ_STATE_STOPPED);
1758 }
else if (mode == STOP_SELECTED) {
1759 XcpDaq_StopSelectedLists();
1761 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1764 Xcp_PositiveResponse();
1767 XCP_STATIC
void Xcp_GetDaqListMode_Res(Xcp_PduType
const *
const pdu) {
1768 DBG_TRACE1(
"GET_DAQ_LIST_MODE\n\r");
1769 XCP_ASSERT_PGM_IDLE();
1770 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1771 Xcp_PositiveResponse();
1774 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON 1776 XCP_STATIC
void Xcp_GetDaqProcessorInfo_Res(Xcp_PduType
const *
const pdu) {
1777 uint8_t properties = UINT8(0);
1778 XcpDaq_ListIntegerType listCount = (XcpDaq_ListIntegerType)0;
1780 DBG_TRACE1(
"GET_DAQ_PROCESSOR_INFO\n\r");
1781 XCP_ASSERT_PGM_IDLE();
1782 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1784 XcpDaq_GetProperties(&properties);
1785 listCount = XcpDaq_GetListCount();
1787 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), properties,
1788 XCP_LOBYTE(listCount), XCP_HIBYTE(listCount),
1789 XCP_LOBYTE(UINT16(XCP_DAQ_MAX_EVENT_CHANNEL)),
1790 XCP_HIBYTE(UINT16(XCP_DAQ_MAX_EVENT_CHANNEL)),
1791 #
if XCP_DAQ_ENABLE_PREDEFINED_LISTS == XCP_ON
1792 XcpDaq_PredefinedListCount,
1801 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON 1803 XCP_STATIC
void Xcp_GetDaqListInfo_Res(Xcp_PduType
const *
const pdu) {
1804 const XcpDaq_ListIntegerType daqListNumber =
1805 (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1806 XcpDaq_ListConfigurationType
const *listConf = XCP_NULL;
1808 uint8_t properties = UINT8(0x00);
1810 DBG_TRACE2(
"GET_DAQ_LIST_INFO [daq: %u] \n\r", daqListNumber);
1811 XCP_ASSERT_PGM_IDLE();
1812 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1814 if (daqListNumber >= XcpDaq_GetListCount()) {
1815 Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1818 listConf = XcpDaq_GetListConfiguration(daqListNumber);
1821 properties |= DAQ_LIST_PROPERTY_PREDEFINED;
1822 properties |= DAQ_LIST_PROPERTY_EVENT_FIXED;
1823 properties |= DAQ_LIST_PROPERTY_DAQ;
1825 #if XCP_DAQ_ENABLE_PREDEFINED_LISTS == XCP_ON 1826 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), properties,
1827 listConf->numOdts, 0,
1829 UINT8(0), UINT8(0), UINT8(0));
1831 Xcp_ErrorResponse(UINT8(ERR_CMD_SYNTAX));
1837 #if XCP_ENABLE_FREE_DAQ == XCP_ON 1839 XCP_STATIC
void Xcp_FreeDaq_Res(Xcp_PduType
const *
const pdu) {
1840 DBG_TRACE1(
"FREE_DAQ\n\r");
1841 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1842 XCP_ASSERT_PGM_IDLE();
1843 Xcp_SendResult(XcpDaq_Free());
1848 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON 1850 XCP_STATIC
void Xcp_AllocDaq_Res(Xcp_PduType
const *
const pdu) {
1851 XcpDaq_ListIntegerType daqCount = (XcpDaq_ListIntegerType)0;
1853 XCP_ASSERT_PGM_IDLE();
1854 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1855 daqCount = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1856 DBG_TRACE2(
"ALLOC_DAQ [count: %u] \n\r", daqCount);
1857 Xcp_SendResult(XcpDaq_Alloc(daqCount));
1862 #if XCP_ENABLE_ALLOC_ODT == XCP_ON 1864 XCP_STATIC
void Xcp_AllocOdt_Res(Xcp_PduType
const *
const pdu) {
1865 XcpDaq_ListIntegerType daqListNumber = (XcpDaq_ListIntegerType)0;
1866 XcpDaq_ODTIntegerType odtCount = (XcpDaq_ODTIntegerType)0;
1868 XCP_ASSERT_PGM_IDLE();
1869 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1870 daqListNumber = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1871 odtCount = Xcp_GetByte(pdu, UINT8(4));
1872 DBG_TRACE3(
"ALLOC_ODT [daq: %u count: %u] \n\r", daqListNumber, odtCount);
1873 Xcp_SendResult(XcpDaq_AllocOdt(daqListNumber, odtCount));
1878 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON 1880 XCP_STATIC
void Xcp_AllocOdtEntry_Res(Xcp_PduType
const *
const pdu) {
1881 XcpDaq_ListIntegerType daqListNumber = (XcpDaq_ListIntegerType)0;
1882 XcpDaq_ODTIntegerType odtNumber = (XcpDaq_ODTIntegerType)0;
1883 XcpDaq_ODTEntryIntegerType odtEntriesCount = (XcpDaq_ODTEntryIntegerType)0;
1885 XCP_ASSERT_PGM_IDLE();
1886 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1887 daqListNumber = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1888 odtNumber = Xcp_GetByte(pdu, UINT8(4));
1889 odtEntriesCount = Xcp_GetByte(pdu, UINT8(5));
1890 DBG_TRACE4(
"ALLOC_ODT_ENTRY: [daq: %u odt: %u count: %u]\n\r", daqListNumber,
1891 odtNumber, odtEntriesCount);
1893 XcpDaq_AllocOdtEntry(daqListNumber, odtNumber, odtEntriesCount));
1898 #if XCP_ENABLE_GET_DAQ_CLOCK == XCP_ON 1900 XCP_STATIC
void Xcp_GetDaqClock_Res(Xcp_PduType
const *
const pdu) {
1901 uint32_t timestamp = UINT32(0);
1903 XCP_ASSERT_PGM_IDLE();
1904 #if XCP_DAQ_CLOCK_ACCESS_ALWAYS_SUPPORTED == XCP_OFF 1905 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1908 timestamp = XcpHw_GetTimerCounter();
1909 DBG_TRACE2(
"GET_DAQ_CLOCK [timestamp: %u]\n\r", timestamp);
1911 UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0), UINT8(0), UINT8(0),
1912 XCP_LOBYTE(XCP_LOWORD(timestamp)), XCP_HIBYTE(XCP_LOWORD(timestamp)),
1913 XCP_LOBYTE(XCP_HIWORD(timestamp)), XCP_HIBYTE(XCP_HIWORD(timestamp)));
1918 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON 1920 XCP_STATIC
void Xcp_GetDaqResolutionInfo_Res(Xcp_PduType
const *
const pdu) {
1921 DBG_TRACE1(
"GET_DAQ_RESOLUTION_INFO\n\r");
1922 XCP_ASSERT_PGM_IDLE();
1923 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1925 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES),
1927 UINT8(XCP_DAQ_MAX_ODT_ENTRY_SIZE),
1930 UINT8(XCP_DAQ_MAX_ODT_ENTRY_SIZE),
1939 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON 1941 XCP_STATIC
void Xcp_GetDaqEventInfo_Res(Xcp_PduType
const *
const pdu) {
1942 uint16_t eventChannel = Xcp_GetWord(pdu, UINT8(2));
1943 uint8_t nameLen = UINT8(0);
1944 XcpDaq_EventType
const *
event = XCP_NULL;
1946 DBG_TRACE2(
"GET_DAQ_EVENT_INFO [eventChannel: %d]\n\r", eventChannel);
1947 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1949 if (eventChannel >= UINT8(XCP_DAQ_MAX_EVENT_CHANNEL)) {
1950 Xcp_SendResult(ERR_OUT_OF_RANGE);
1953 event = XcpDaq_GetEventConfiguration(eventChannel);
1954 if ((event->name == XCP_NULL) || (event->nameLen == UINT8(0))) {
1957 nameLen =
event->nameLen;
1958 Xcp_SetMta(Xcp_GetNonPagedAddress(event->name));
1961 Xcp_Send8(UINT8(7), UINT8(XCP_PACKET_IDENTIFIER_RES),
1962 UINT8(event->properties),
1966 UINT8(event->cycle),
1967 UINT8(event->timeunit),
1982 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 1984 XCP_STATIC
void Xcp_ProgramStart_Res(Xcp_PduType
const *
const pdu) {
1985 DBG_TRACE1(
"PROGRAM_START\n\r");
1986 XCP_ASSERT_UNLOCKED(XCP_RESOURCE_PGM);
1987 XCP_ASSERT_DAQ_STOPPED();
1988 XcpPgm_SetProcessorState(XCP_PGM_ACTIVE);
1991 UINT8(7), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0),
1994 UINT8(XCP_MAX_BS_PGM),
1995 UINT8(XCP_MIN_ST_PGM),
2000 XCP_STATIC
void Xcp_ProgramClear_Res(Xcp_PduType
const *
const pdu) {
2001 uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
2002 uint32_t clearRange = Xcp_GetDWord(pdu, UINT8(4));
2004 DBG_TRACE3(
"PROGRAM_CLEAR [mode: %d clearRange: 0x%08x]\n\r", mode,
2006 XCP_ASSERT_PGM_ACTIVE();
2008 Xcp_PositiveResponse();
2011 XCP_STATIC
void Xcp_Program_Res(Xcp_PduType
const *
const pdu) {
2012 uint8_t len = Xcp_GetByte(pdu, UINT8(1));
2013 Xcp_MtaType src = {0};
2015 DBG_TRACE2(
"PROGRAM [len: %u]\n\r", len);
2017 XCP_ASSERT_PGM_ACTIVE();
2018 XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_WRITE,
2020 src.address = (Xcp_PointerSizeType)pdu->data + 2;
2024 XCP_INCREMENT_MTA(len);
2026 Xcp_PositiveResponse();
2029 XCP_STATIC
void Xcp_ProgramReset_Res(Xcp_PduType
const *
const pdu) {
2030 DBG_TRACE1(
"PROGRAM_RESET\n\r");
2031 XCP_ASSERT_PGM_ACTIVE();
2033 XcpPgm_SetProcessorState(XCP_PGM_IDLE);
2034 Xcp_PositiveResponse();
2037 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON 2039 XCP_STATIC
void Xcp_GetPgmProcessorInfo_Res(Xcp_PduType
const *
const pdu) {
2040 DBG_TRACE1(
"GET_PGM_PROCESSOR_INFO\n\r");
2043 Xcp_Send8(UINT8(3), UINT8(XCP_PACKET_IDENTIFIER_RES),
2046 UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
2051 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON 2053 XCP_STATIC
void Xcp_GetSectorInfo_Res(Xcp_PduType
const *
const pdu) {
2054 uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
2055 uint8_t sectorNumber = Xcp_GetByte(pdu, UINT8(2));
2057 DBG_TRACE3(
"GET_SECTOR_INFO [sectorNumber: %d mode :%d]\n\r", sectorNumber,
2062 if (sectorNumber >= XCP_MAX_SECTOR_PGM) {
2063 Xcp_SendResult(ERR_SEGMENT_NOT_VALID);
2067 if (mode == UINT8(0)) {
2069 }
else if (mode == UINT8(1)) {
2072 Xcp_SendResult(ERR_MODE_NOT_VALID);
2076 Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES),
2077 UINT8(sectorNumber * 2),
2078 UINT8((sectorNumber * 2) + 1),
2081 UINT8(0), UINT8(0), UINT8(0));
2086 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON 2088 XCP_STATIC
void Xcp_ProgramPrepare_Res(Xcp_PduType
const *
const pdu) {
2089 uint16_t codeSize = Xcp_GetWord(pdu, UINT8(2));
2091 DBG_TRACE2(
"PROGRAM_PREPARE [codeSize: %d]\n\r", codeSize);
2092 XCP_ASSERT_PGM_ACTIVE();
2094 Xcp_PositiveResponse();
2099 #if XCP_ENABLE_PROGRAM_FORMAT == XCP_ON 2100 XCP_STATIC
void Xcp_ProgramFormat_Res(Xcp_PduType
const *
const pdu) {
2101 uint8_t compressionMethod = Xcp_GetByte(pdu, UINT8(1));
2102 uint8_t encryptionMethod = Xcp_GetByte(pdu, UINT8(2));
2103 uint8_t programmingMethod = Xcp_GetByte(pdu, UINT8(3));
2104 uint8_t accessMethod = Xcp_GetByte(pdu, UINT8(4));
2106 DBG_TRACE5(
"PROGRAM_FORMAT [compression: %d encryption: %d programming: %d " 2108 compressionMethod, encryptionMethod, programmingMethod,
2110 XCP_ASSERT_PGM_ACTIVE();
2112 Xcp_PositiveResponse();
2116 #if XCP_ENABLE_PROGRAM_NEXT == XCP_ON 2117 XCP_STATIC
void Xcp_ProgramNext_Res(Xcp_PduType
const *
const pdu) {
2118 DBG_TRACE1(
"PROGRAM_NEXT\n\r");
2119 XCP_ASSERT_PGM_ACTIVE();
2121 Xcp_PositiveResponse();
2125 #if XCP_ENABLE_PROGRAM_MAX == XCP_ON 2126 XCP_STATIC
void Xcp_ProgramMax_Res(Xcp_PduType
const *
const pdu) {
2127 DBG_TRACE1(
"PROGRAM_MAX\n\r");
2128 XCP_ASSERT_PGM_ACTIVE();
2130 Xcp_PositiveResponse();
2134 #if XCP_ENABLE_PROGRAM_VERIFY == XCP_ON 2135 XCP_STATIC
void Xcp_ProgramVerify_Res(Xcp_PduType
const *
const pdu) {
2136 DBG_TRACE1(
"PROGRAM_VERIFY\n\r");
2137 XCP_ASSERT_PGM_ACTIVE();
2139 Xcp_PositiveResponse();
2148 XCP_STATIC
void Xcp_SendResult(Xcp_ReturnType result) {
2149 if (result == ERR_SUCCESS) {
2150 Xcp_PositiveResponse();
2152 Xcp_ErrorResponse(UINT8(result));
2157 void Xcp_WriteMemory(
void * dest,
void * src, uint16_t count)
2159 XcpUtl_MemCopy(dest, src, UINT32(count));
2163 #if XCP_REPLACE_STD_COPY_MEMORY == XCP_OFF 2165 void Xcp_CopyMemory(Xcp_MtaType dst, Xcp_MtaType src, uint32_t len) {
2166 #if XCP_ENABLE_ADDRESS_MAPPER == XCP_ON 2167 Xcp_MtaType tmpD = {0};
2168 Xcp_MtaType tmpS = {0};
2169 Xcp_MemoryMappingResultType res = XCP_MEMORY_ADDRESS_INVALID;
2171 tmpD.address = dst.address;
2172 tmpS.address = src.address;
2174 res = Xcp_HookFunction_AddressMapper(&tmpD, &dst);
2175 if (res == XCP_MEMORY_MAPPED) {
2176 }
else if (res == XCP_MEMORY_NOT_MAPPED) {
2177 }
else if (res == XCP_MEMORY_ADDRESS_INVALID) {
2180 res = Xcp_HookFunction_AddressMapper(&tmpS, &src);
2181 if (res == XCP_MEMORY_MAPPED) {
2182 }
else if (res == XCP_MEMORY_NOT_MAPPED) {
2183 }
else if (res == XCP_MEMORY_ADDRESS_INVALID) {
2186 XcpUtl_MemCopy((
void *)tmpD.address, (
void *)tmpS.address, len);
2190 XcpUtl_MemCopy((
void *)dst.address, (
void *)src.address, len);
2196 INLINE uint8_t Xcp_GetByte(Xcp_PduType
const *
const pdu, uint8_t offs) {
2197 return (*(pdu->data + offs));
2200 INLINE uint16_t Xcp_GetWord(Xcp_PduType
const *
const pdu, uint8_t offs) {
2201 #if XCP_BYTE_ORDER == XCP_BYTE_ORDER_INTEL 2202 return ((*(pdu->data + offs)) & UINT8(0xff)) |
2203 (((*(pdu->data + UINT8(1) + offs)) & UINT8(0xff)) << UINT8(8));
2204 #elif XCP_BYTE_ORDER == XCP_BYTE_ORDER_MOTOROLA 2205 return (((*(pdu->data + offs)) & UINT8(0xff)) << UINT8(8)) |
2206 ((*(pdu->data + UINT8(1) + offs)) & UINT8(0xff));
2210 INLINE uint32_t Xcp_GetDWord(Xcp_PduType
const *
const pdu, uint8_t offs) {
2211 uint16_t h = UINT16(0);
2212 uint16_t l = UINT16(0);
2214 #if XCP_BYTE_ORDER == XCP_BYTE_ORDER_INTEL 2215 l = Xcp_GetWord(pdu, offs + 0);
2216 h = Xcp_GetWord(pdu, offs + 2);
2217 #elif XCP_BYTE_ORDER == XCP_BYTE_ORDER_MOTOROLA 2218 h = Xcp_GetWord(pdu, offs + 0);
2219 l = Xcp_GetWord(pdu, offs + 2);
2221 return (uint32_t)(h * 0x10000) + l;
2224 INLINE
void Xcp_SetByte(Xcp_PduType
const *
const pdu, uint8_t offs,
2226 (*(pdu->data + offs)) = value;
2229 INLINE
void Xcp_SetWord(Xcp_PduType
const *
const pdu, uint8_t offs,
2231 #if XCP_BYTE_ORDER == XCP_BYTE_ORDER_INTEL 2232 (*(pdu->data + offs)) = value & UINT8(0xff);
2233 (*(pdu->data + UINT8(1) + offs)) = (value & UINT16(0xff00)) >> UINT8(8);
2234 #elif XCP_BYTE_ORDER == XCP_BYTE_ORDER_MOTOROLA 2235 (*(pdu->data + offs)) = (value & UINT16(0xff00)) >> UINT8(8);
2236 (*(pdu->data + UINT8(1) + offs)) = value & UINT8(0xff);
2240 INLINE
void Xcp_SetDWord(Xcp_PduType
const *
const pdu, uint8_t offs,
2242 #if XCP_BYTE_ORDER == XCP_BYTE_ORDER_INTEL 2243 Xcp_SetWord(pdu, offs + 2, (value & UINT32(0xffff0000)) >> UINT8(16));
2244 Xcp_SetWord(pdu, offs + 0, value & UINT32(0x0000ffff));
2245 #elif XCP_BYTE_ORDER == XCP_BYTE_ORDER_MOTOROLA 2246 Xcp_SetWord(pdu, offs + 0, (value & UINT32(0xffff0000)) >> UINT8(16));
2247 Xcp_SetWord(pdu, offs + 2, value & UINT32(0x0000ffff));
2251 XCP_STATIC uint8_t Xcp_SetResetBit8(uint8_t result, uint8_t value,
2253 if ((value & flag) == flag) {
2261 #if XCP_ENABLE_RESOURCE_PROTECTION == XCP_ON 2262 XCP_STATIC
bool Xcp_IsProtected(uint8_t resource) {
2263 return ((Xcp_State.resourceProtection & resource) == resource);
2267 XCP_STATIC
bool Xcp_IsProtected(uint8_t resource) {
return XCP_FALSE; }
2271 void Xcp_SetBusy(
bool enable) {
2272 XCP_ENTER_CRITICAL();
2273 Xcp_State.busy = enable;
2274 XCP_LEAVE_CRITICAL();
2277 bool Xcp_IsBusy(
void) {
return Xcp_State.busy; }
2279 Xcp_StateType *Xcp_GetState(
void) {
2280 Xcp_StateType *tState = XCP_NULL;
2282 XCP_DAQ_ENTER_CRITICAL();
2283 tState = &Xcp_State;
2284 XCP_DAQ_LEAVE_CRITICAL();
2289 XCP_STATIC
void Xcp_PositiveResponse(
void) {
2290 Xcp_Send8(UINT8(1), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0), UINT8(0),
2291 UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
2294 XCP_STATIC
void Xcp_ErrorResponse(uint8_t errorCode) {
2295 Xcp_Send8(UINT8(2), UINT8(XCP_PACKET_IDENTIFIER_ERR), UINT8(errorCode),
2296 UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
2299 XCP_STATIC
void Xcp_BusyResponse(
void) {
2300 #if XCP_ENABLE_STATISTICS == XCP_ON 2301 Xcp_State.statistics.crosBusy++;
2303 Xcp_ErrorResponse(ERR_CMD_BUSY);
2306 #if (XCP_ENABLE_SERVICE_REQUEST_API == XCP_ON) || (XCP_ENABLE_EVENT_PACKET_API) 2308 XCP_STATIC
void Xcp_SendSpecialPacket(uint8_t packetType, uint8_t code,
2309 uint8_t
const *
const data,
2310 uint8_t dataLength) {
2311 uint8_t *dataOut = Xcp_GetCtoOutPtr();
2312 uint8_t frameLength = UINT8(0);
2313 uint8_t idx = UINT8(0);
2315 dataLength = XCP_MIN(XCP_MAX_CTO - 2, dataLength);
2317 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON 2318 frameLength = XCP_MAX_CTO;
2320 frameLength = dataLength + 2;
2322 Xcp_SetCtoOutLen(UINT16(frameLength));
2323 dataOut[0] = packetType;
2326 for (idx = UINT8(0); idx < dataLength; ++idx) {
2327 dataOut[2 + idx] = data[idx];
2335 #if XCP_ENABLE_EVENT_PACKET_API == XCP_ON 2337 void Xcp_SendEventPacket(uint8_t eventCode, uint8_t
const *
const eventInfo,
2338 uint8_t eventInfoLength) {
2339 Xcp_SendSpecialPacket(XCP_PACKET_IDENTIFIER_EV, eventCode, eventInfo,
2345 #if XCP_ENABLE_SERVICE_REQUEST_API == XCP_ON 2346 void Xcp_SendServiceRequestPacket(uint8_t serviceRequestCode,
2347 uint8_t
const *
const serviceRequest,
2348 uint8_t serviceRequestLength) {
2349 Xcp_SendSpecialPacket(XCP_PACKET_IDENTIFIER_SERV, serviceRequestCode,
2350 serviceRequest, serviceRequestLength);
2355 XCP_STATIC Xcp_MemoryMappingResultType Xcp_MapMemory(Xcp_MtaType
const * src, Xcp_MtaType * dst)
2357 Xcp_MemoryMappingResultType mappingResult;
2362 printf(
"addr: %x ext: %d\n", mta->address, mta->ext);
2363 if ((mta->address >= 0x4000) && (mta->address < 0x5000)) {
2364 mta->address = (0x00A90000 - 0x4000) + mta->address;
2366 printf(
"MAPPED: addr: %x ext: %d\n", mta->address, mta->ext);
2370 XCP_STATIC
void Xcp_Download_Copy(uint32_t address, uint8_t ext, uint32_t len) {
2371 Xcp_MtaType src = {0};
2373 src.address = address;
2375 Xcp_CopyMemory(Xcp_State.mta, src, len);
2376 XCP_INCREMENT_MTA(len);
2379 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON 2381 void XcpPgm_SetProcessorState(XcpPgm_ProcessorStateType state) {
2382 Xcp_StateType *tmpState = {0};
2384 tmpState = Xcp_GetState();
2385 XCP_PGM_ENTER_CRITICAL();
2386 tmpState->pgmProcessor.state = state;
2387 XCP_PGM_LEAVE_CRITICAL();
2392 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON 2394 XCP_STATIC
void Xcp_WriteDaqEntry(uint8_t bitOffset, uint8_t elemSize,
2395 uint8_t adddrExt, uint32_t address) {
2396 XcpDaq_ODTEntryType *entry = XCP_NULL;
2399 "\tentry: [address: 0x%08x ext: 0x%02x size: %u bitOffset: %u]\n\r",
2400 address, adddrExt, elemSize, bitOffset);
2403 XcpDaq_GetOdtEntry(Xcp_State.daqPointer.daqList, Xcp_State.daqPointer.odt,
2404 Xcp_State.daqPointer.odtEntry);
2406 #if XCP_DAQ_BIT_OFFSET_SUPPORTED == XCP_ON 2407 entry->bitOffset = bitOffset;
2409 entry->length = elemSize;
2410 entry->mta.address = address;
2411 #if XCP_DAQ_ADDR_EXT_SUPPORTED == XCP_ON 2412 entry->mta.ext = adddrExt;
2419 Xcp_State.daqPointer.odtEntry += (XcpDaq_ODTEntryIntegerType)1;