XCP_SIM
xcp.c
1 /*
2  * BlueParrot XCP
3  *
4  * (C) 2007-2022 by Christoph Schueler <github.com/Christoph2,
5  * cpu12.gems@googlemail.com>
6  *
7  * All Rights Reserved
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  *
23  * s. FLOSS-EXCEPTION.txt
24  */
25 
27 #include "xcp.h"
28 
29 #include "xcp_hw.h"
32 /*
33 ** Private Options.
34 */
35 #define XCP_ENABLE_STD_COMMANDS XCP_ON
36 #define XCP_ENABLE_INTERLEAVED_MODE XCP_OFF
37 
38 #define XCP_DRIVER_VERSION (10)
39 
40 /*
41  * Local Constants.
42  */
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);
45 
46 /*
47 ** Local Variables.
48 */
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};
54 
55 /*
56 ** Global Variables.
57 */
58 Xcp_PduType Xcp_CtoIn = {0, &Xcp_CtoInBuffer[0]};
59 Xcp_PduType Xcp_CtoOut = {0, &Xcp_CtoOutBuffer[0]};
60 
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]};
64 #endif /* XCP_ENABLE_DAQ_COMMANDS */
65 
66 void Xcp_WriteMemory(void *dest, void *src, uint16_t count);
67 
68 void Xcp_ReadMemory(void *dest, void *src, uint16_t count);
69 
70 /*
71 ** Local Macros.
72 */
73 #define STOP_ALL UINT8(0x00)
74 #define START_SELECTED UINT8(0x01)
75 #define STOP_SELECTED UINT8(0x02)
76 
77 #define XCP_INCREMENT_MTA(i) Xcp_State.mta.address += UINT32((i))
78 
79 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
80 #define XCP_ASSERT_DAQ_STOPPED() \
81  do { \
82  if (Xcp_State.daqProcessor.state == XCP_DAQ_STATE_RUNNING) { \
83  Xcp_SendResult(ERR_DAQ_ACTIVE); \
84  return; \
85  } \
86  } while (0)
87 #else
88 #define XCP_ASSERT_DAQ_STOPPED()
89 #endif /* ENABLE_DAQ_COMMANDS */
90 
91 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
92 #define XCP_ASSERT_PGM_IDLE() \
93  do { \
94  if (Xcp_State.pgmProcessor.state == XCP_PGM_ACTIVE) { \
95  Xcp_SendResult(ERR_PGM_ACTIVE); \
96  return; \
97  } \
98  } while (0)
99 #else
100 #define XCP_ASSERT_PGM_IDLE()
101 #endif /* ENABLE_PGM_COMMANDS */
102 
103 #define XCP_ASSERT_PGM_ACTIVE() \
104  do { \
105  if (Xcp_State.pgmProcessor.state != XCP_PGM_ACTIVE) { \
106  Xcp_SendResult(ERR_SEQUENCE); \
107  return; \
108  } \
109  } while (0)
110 
111 #define XCP_ASSERT_UNLOCKED(r) \
112  do { \
113  if (Xcp_IsProtected((r))) { \
114  Xcp_SendResult(ERR_ACCESS_LOCKED); \
115  return; \
116  } \
117  } while (0)
118 
119 #if XCP_ENABLE_CHECK_MEMORY_ACCESS == XCP_ON
120 #define XCP_CHECK_MEMORY_ACCESS(m, l, a, p) \
121  do { \
122  if (!Xcp_HookFunction_CheckMemoryAccess((m), (l), (a), (p))) { \
123  Xcp_SendResult(ERR_ACCESS_DENIED); \
124  return; \
125  } \
126  } while (0)
127 #else
128 #define XCP_CHECK_MEMORY_ACCESS(m, l, a, p)
129 #endif /* XCP_ENABLE_CHECK_MEMORY_ACCESS */
130 
131 /*
132 ** Local Function Prototypes.
133 */
134 XCP_STATIC uint8_t Xcp_SetResetBit8(uint8_t result, uint8_t value,
135  uint8_t flag);
136 
137 XCP_STATIC Xcp_MemoryMappingResultType Xcp_MapMemory(Xcp_MtaType const *src,
138  Xcp_MtaType *dst);
139 
140 XCP_STATIC void Xcp_Download_Copy(uint32_t address, uint8_t ext, uint32_t len);
141 
142 XCP_STATIC void Xcp_PositiveResponse(void);
143 
144 XCP_STATIC void Xcp_ErrorResponse(uint8_t errorCode);
145 
146 XCP_STATIC void Xcp_BusyResponse(void);
147 
148 #if (XCP_ENABLE_SERVICE_REQUEST_API == XCP_ON) || (XCP_ENABLE_EVENT_PACKET_API)
149 
150 XCP_STATIC void Xcp_SendSpecialPacket(uint8_t packetType, uint8_t code,
151  uint8_t const *const data,
152  uint8_t dataLength);
153 
154 #endif
155 
156 XCP_STATIC bool Xcp_IsProtected(uint8_t resource);
157 
158 XCP_STATIC void Xcp_DefaultResourceProtection(void);
159 
160 XCP_STATIC void Xcp_WriteDaqEntry(uint8_t bitOffset, uint8_t elemSize,
161  uint8_t adddrExt, uint32_t address);
162 
163 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON
164 XCP_STATIC bool Xcp_SlaveBlockTransferIsActive(void);
165 XCP_STATIC void Xcp_SlaveBlockTransferSetActive(bool onOff);
166 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
167 
168 XCP_STATIC void Xcp_SendResult(Xcp_ReturnType result);
169 
170 XCP_STATIC void Xcp_CommandNotImplemented_Res(Xcp_PduType const *const pdu);
171 
172 XCP_STATIC void Xcp_Connect_Res(Xcp_PduType const *const pdu);
173 
174 XCP_STATIC void Xcp_Disconnect_Res(Xcp_PduType const *const pdu);
175 
176 XCP_STATIC void Xcp_GetStatus_Res(Xcp_PduType const *const pdu);
177 
178 XCP_STATIC void Xcp_Synch_Res(Xcp_PduType const *const pdu);
179 
180 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON
181 
182 XCP_STATIC void Xcp_GetCommModeInfo_Res(Xcp_PduType const *const pdu);
183 
184 #endif /* XCP_ENABLE_GET_COMM_MODE_INFO */
185 #if XCP_ENABLE_GET_ID == XCP_ON
186 
187 XCP_STATIC void Xcp_GetId_Res(Xcp_PduType const *const pdu);
188 
189 #endif /* XCP_ENABLE_GET_ID */
190 #if XCP_ENABLE_SET_REQUEST == XCP_ON
191 XCP_STATIC void Xcp_SetRequest_Res(Xcp_PduType const *const pdu);
192 #endif /* XCP_ENABLE_SET_REQUEST */
193 #if XCP_ENABLE_GET_SEED == XCP_ON
194 XCP_STATIC void Xcp_GetSeed_Res(Xcp_PduType const *const pdu);
195 #endif /* XCP_ENABLE_GET_SEED */
196 #if XCP_ENABLE_UNLOCK == XCP_ON
197 XCP_STATIC void Xcp_Unlock_Res(Xcp_PduType const *const pdu);
198 #endif /* XCP_ENABLE_UNLOCK */
199 #if XCP_ENABLE_SET_MTA == XCP_ON
200 
201 XCP_STATIC void Xcp_SetMta_Res(Xcp_PduType const *const pdu);
202 
203 #endif /* XCP_ENABLE_SET_MTA */
204 #if XCP_ENABLE_UPLOAD == XCP_ON
205 
206 XCP_STATIC void Xcp_Upload_Res(Xcp_PduType const *const pdu);
207 
208 #endif
209 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON
210 
211 XCP_STATIC void Xcp_ShortUpload_Res(Xcp_PduType const *const pdu);
212 
213 #endif /* XCP_ENABLE_SHORT_UPLOAD */
214 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON
215 
216 XCP_STATIC void Xcp_BuildChecksum_Res(Xcp_PduType const *const pdu);
217 
218 #endif
219 #if XCP_ENABLE_TRANSPORT_LAYER_CMD == XCP_ON
220 XCP_STATIC void Xcp_TransportLayerCmd_Res(Xcp_PduType const *const pdu);
221 #endif /* XCP_ENABLE_TRANSPORT_LAYER_CMD */
222 #if XCP_ENABLE_USER_CMD == XCP_ON
223 XCP_STATIC void Xcp_UserCmd_Res(Xcp_PduType const *const pdu);
224 #endif /* XCP_ENABLE_USER_CMD */
225 
226 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON
227 
228 XCP_STATIC void Xcp_Download_Res(Xcp_PduType const *const pdu);
229 
230 #if XCP_ENABLE_DOWNLOAD_NEXT == XCP_ON
231 XCP_STATIC void Xcp_DownloadNext_Res(Xcp_PduType const *const pdu);
232 #endif /* XCP_ENABLE_DOWNLOAD_NEXT */
233 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON
234 
235 XCP_STATIC void Xcp_DownloadMax_Res(Xcp_PduType const *const pdu);
236 
237 #endif /* XCP_ENABLE_DOWNLOAD_MAX */
238 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON
239 
240 XCP_STATIC void Xcp_ShortDownload_Res(Xcp_PduType const *const pdu);
241 
242 #endif /* XCP_ENABLE_SHORT_DOWNLOAD */
243 #if XCP_ENABLE_MODIFY_BITS == XCP_ON
244 
245 XCP_STATIC void Xcp_ModifyBits_Res(Xcp_PduType const *const pdu);
246 
247 #endif /* XCP_ENABLE_MODIFY_BITS */
248 
249 XCP_STATIC void Xcp_SetCalPage_Res(Xcp_PduType const *const pdu);
250 
251 XCP_STATIC void Xcp_GetCalPage_Res(Xcp_PduType const *const pdu);
252 
253 #endif /* XCP_ENABLE_CAL_COMMANDS */
254 
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);
258 #endif /* XCP_ENABLE_GET_PAG_PROCESSOR_INFO */
259 #if XCP_ENABLE_GET_SEGMENT_INFO == XCP_ON
260 XCP_STATIC void Xcp_GetSegmentInfo_Res(Xcp_PduType const *const pdu);
261 #endif /* XCP_ENABLE_GET_SEGMENT_INFO */
262 #if XCP_ENABLE_GET_PAGE_INFO == XCP_ON
263 XCP_STATIC void Xcp_GetPageInfo_Res(Xcp_PduType const *const pdu);
264 #endif
265 #if XCP_ENABLE_SET_SEGMENT_MODE == XCP_ON
266 XCP_STATIC void Xcp_SetSegmentMode_Res(Xcp_PduType const *const pdu);
267 #endif /* XCP_ENABLE_SET_SEGMENT_MODE */
268 #if XCP_ENABLE_GET_SEGMENT_MODE == XCP_ON
269 XCP_STATIC void Xcp_GetSegmentMode_Res(Xcp_PduType const *const pdu);
270 #endif /* XCP_ENABLE_GET_SEGMENT_MODE */
271 #if XCP_ENABLE_COPY_CAL_PAGE
272 XCP_STATIC void Xcp_CopyCalPage_Res(Xcp_PduType const *const pdu);
273 #endif /* XCP_ENABLE_COPY_CAL_PAGE */
274 #endif /* XCP_ENABLE_PAG_COMMANDS */
275 
276 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
277 
278 XCP_STATIC void Xcp_ClearDaqList_Res(Xcp_PduType const *const pdu);
279 
280 XCP_STATIC void Xcp_SetDaqPtr_Res(Xcp_PduType const *const pdu);
281 
282 XCP_STATIC void Xcp_WriteDaq_Res(Xcp_PduType const *const pdu);
283 
284 XCP_STATIC void Xcp_SetDaqListMode_Res(Xcp_PduType const *const pdu);
285 
286 XCP_STATIC void Xcp_GetDaqListMode_Res(Xcp_PduType const *const pdu);
287 
288 XCP_STATIC void Xcp_StartStopDaqList_Res(Xcp_PduType const *const pdu);
289 
290 XCP_STATIC void Xcp_StartStopSynch_Res(Xcp_PduType const *const pdu);
291 
292 #if XCP_ENABLE_GET_DAQ_CLOCK == XCP_ON
293 
294 XCP_STATIC void Xcp_GetDaqClock_Res(Xcp_PduType const *const pdu);
295 
296 #endif /* XCP_ENABLE_GET_DAQ_CLOCK */
297 #if XCP_ENABLE_READ_DAQ == XCP_ON
298 XCP_STATIC void Xcp_ReadDaq_Res(Xcp_PduType const *const pdu);
299 #endif /* XCP_ENABLE_READ_DAQ */
300 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON
301 
302 XCP_STATIC void Xcp_GetDaqProcessorInfo_Res(Xcp_PduType const *const pdu);
303 
304 #endif /* XCP_ENABLE_GET_DAQ_PROCESSOR_INFO */
305 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON
306 
307 XCP_STATIC void Xcp_GetDaqResolutionInfo_Res(Xcp_PduType const *const pdu);
308 
309 #endif /* XCP_ENABLE_GET_DAQ_RESOLUTION_INFO */
310 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON
311 
312 XCP_STATIC void Xcp_GetDaqListInfo_Res(Xcp_PduType const *const pdu);
313 
314 #endif /* XCP_ENABLE_GET_DAQ_LIST_INFO */
315 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON
316 
317 XCP_STATIC void Xcp_GetDaqEventInfo_Res(Xcp_PduType const *const pdu);
318 
319 #endif /* XCP_ENABLE_GET_DAQ_EVENT_INFO */
320 #if XCP_ENABLE_FREE_DAQ == XCP_ON
321 
322 XCP_STATIC void Xcp_FreeDaq_Res(Xcp_PduType const *const pdu);
323 
324 #endif /* XCP_ENABLE_FREE_DAQ */
325 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON
326 
327 XCP_STATIC void Xcp_AllocDaq_Res(Xcp_PduType const *const pdu);
328 
329 #endif /* XCP_ENABLE_ALLOC_DAQ */
330 #if XCP_ENABLE_ALLOC_ODT == XCP_ON
331 
332 XCP_STATIC void Xcp_AllocOdt_Res(Xcp_PduType const *const pdu);
333 
334 #endif /* XCP_ENABLE_ALLOC_ODT */
335 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON
336 
337 XCP_STATIC void Xcp_AllocOdtEntry_Res(Xcp_PduType const *const pdu);
338 
339 #endif /* XCP_ENABLE_ALLOC_ODT_ENTRY */
340 #if XCP_ENABLE_WRITE_DAQ_MULTIPLE == XCP_ON
341 XCP_STATIC void Xcp_WriteDaqMultiple_Res(Xcp_PduType const *const pdu);
342 #endif /* XCP_ENABLE_WRITE_DAQ_MULTIPLE */
343 #endif /* XCP_ENABLE_DAQ_COMMANDS */
344 
345 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
346 
347 XCP_STATIC void Xcp_ProgramStart_Res(Xcp_PduType const *const pdu);
348 
349 XCP_STATIC void Xcp_ProgramClear_Res(Xcp_PduType const *const pdu);
350 
351 XCP_STATIC void Xcp_Program_Res(Xcp_PduType const *const pdu);
352 
353 XCP_STATIC void Xcp_ProgramReset_Res(Xcp_PduType const *const pdu);
354 
355 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON
356 
357 XCP_STATIC void Xcp_GetPgmProcessorInfo_Res(Xcp_PduType const *const pdu);
358 
359 #endif /* XCP_ENABLE_GET_PGM_PROCESSOR_INFO */
360 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON
361 
362 XCP_STATIC void Xcp_GetSectorInfo_Res(Xcp_PduType const *const pdu);
363 
364 #endif /* XCP_ENABLE_GET_SECTOR_INFO */
365 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON
366 
367 XCP_STATIC void Xcp_ProgramPrepare_Res(Xcp_PduType const *const pdu);
368 
369 #endif /* XCP_ENABLE_PROGRAM_PREPARE */
370 #if XCP_ENABLE_PROGRAM_FORMAT == XCP_ON
371 XCP_STATIC void Xcp_ProgramFormat_Res(Xcp_PduType const *const pdu);
372 #endif /* XCP_ENABLE_PROGRAM_FORMAT */
373 #if XCP_ENABLE_PROGRAM_NEXT == XCP_ON
374 XCP_STATIC void Xcp_ProgramNext_Res(Xcp_PduType const *const pdu);
375 #endif /* XCP_ENABLE_PROGRAM_NEXT */
376 #if XCP_ENABLE_PROGRAM_MAX == XCP_ON
377 XCP_STATIC void Xcp_ProgramMax_Res(Xcp_PduType const *const pdu);
378 #endif /* XCP_ENABLE_PROGRAM_MAX */
379 #if XCP_ENABLE_PROGRAM_VERIFY == XCP_ON
380 XCP_STATIC void Xcp_ProgramVerify_Res(Xcp_PduType const *const pdu);
381 #endif /* XCP_ENABLE_PROGRAM_VERIFY */
382 #endif /* XCP_ENABLE_PGM_COMMANDS */
383 
384 /*
385 ** Big, fat jump table.
386 */
387 
388 XCP_STATIC const Xcp_ServerCommandType Xcp_ServerCommands[] = {
389 /* lint -save -e632 Assignment to strong type 'Xcp_ServerCommandType'
390  * considered harmless in this context. */
391 #if XCP_ENABLE_STD_COMMANDS == XCP_ON
392  Xcp_Connect_Res,
393  Xcp_Disconnect_Res,
394  Xcp_GetStatus_Res,
395  Xcp_Synch_Res,
396 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON
397  Xcp_GetCommModeInfo_Res,
398 #else
399  Xcp_CommandNotImplemented_Res,
400 #endif
401 #if XCP_ENABLE_GET_ID == XCP_ON
402  Xcp_GetId_Res,
403 #else
404  Xcp_CommandNotImplemented_Res,
405 #endif
406 #if XCP_ENABLE_SET_REQUEST == XCP_ON
407  Xcp_SetRequest_Res,
408 #else
409  Xcp_CommandNotImplemented_Res,
410 #endif
411 #if XCP_ENABLE_GET_SEED == XCP_ON
412  Xcp_GetSeed_Res,
413 #else
414  Xcp_CommandNotImplemented_Res,
415 #endif
416 #if XCP_ENABLE_UNLOCK == XCP_ON
417  Xcp_Unlock_Res,
418 #else
419  Xcp_CommandNotImplemented_Res,
420 #endif
421 #if XCP_ENABLE_SET_MTA == XCP_ON
422  Xcp_SetMta_Res,
423 #else
424  Xcp_CommandNotImplemented_Res,
425 #endif
426 #if XCP_ENABLE_UPLOAD == XCP_ON
427  Xcp_Upload_Res,
428 #else
429  Xcp_CommandNotImplemented_Res,
430 #endif
431 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON
432  Xcp_ShortUpload_Res,
433 #else
434  Xcp_CommandNotImplemented_Res,
435 #endif
436 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON
437  Xcp_BuildChecksum_Res,
438 #else
439  Xcp_CommandNotImplemented_Res,
440 #endif
441 #if XCP_ENABLE_TRANSPORT_LAYER_CMD == XCP_ON
442  Xcp_TransportLayerCmd_Res,
443 #else
444  Xcp_CommandNotImplemented_Res,
445 #endif
446 #if XCP_ENABLE_USER_CMD == XCP_ON
447  Xcp_UserCmd_Res,
448 #else
449  Xcp_CommandNotImplemented_Res,
450 #endif
451 #else
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,
460 #endif
461 
462 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON
463  Xcp_Download_Res,
464 #if XCP_ENABLE_DOWNLOAD_NEXT == XCP_ON
465  Xcp_DownloadNext_Res,
466 #else
467  Xcp_CommandNotImplemented_Res,
468 #endif
469 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON
470  Xcp_DownloadMax_Res,
471 #else
472  Xcp_CommandNotImplemented_Res,
473 #endif
474 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON
475  Xcp_ShortDownload_Res,
476 #else
477  Xcp_CommandNotImplemented_Res,
478 #endif
479 #if XCP_ENABLE_MODIFY_BITS == XCP_ON
480  Xcp_ModifyBits_Res,
481 #else
482  Xcp_CommandNotImplemented_Res,
483 #endif
484 #else
485  Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
486  Xcp_CommandNotImplemented_Res, Xcp_CommandNotImplemented_Res,
487  Xcp_CommandNotImplemented_Res,
488 #endif
489 
490 #if XCP_ENABLE_PAG_COMMANDS == XCP_ON
491  Xcp_SetCalPage_Res,
492  Xcp_GetCalPage_Res,
493 #if XCP_ENABLE_GET_PAG_PROCESSOR_INFO == XCP_ON
494  Xcp_GetPagProcessorInfo_Res,
495 #else
496  Xcp_CommandNotImplemented_Res,
497 #endif
498 #if XCP_ENABLE_GET_SEGMENT_INFO == XCP_ON
499  Xcp_GetSegmentInfo_Res,
500 #else
501  Xcp_CommandNotImplemented_Res,
502 #endif
503 #if XCP_ENABLE_GET_PAGE_INFO == XCP_ON
504  Xcp_GetPageInfo_Res,
505 #else
506  Xcp_CommandNotImplemented_Res,
507 #endif
508 #if XCP_ENABLE_SET_SEGMENT_MODE == XCP_ON
509  Xcp_SetSegmentMode_Res,
510 #else
511  Xcp_CommandNotImplemented_Res,
512 #endif
513 #if XCP_ENABLE_GET_SEGMENT_MODE == XCP_ON
514  Xcp_GetSegmentMode_Res,
515 #else
516  Xcp_CommandNotImplemented_Res,
517 #endif
518 #if XCP_ENABLE_COPY_CAL_PAGE == XCP_ON
519  Xcp_CopyCalPage_Res,
520 #else
521  Xcp_CommandNotImplemented_Res,
522 #endif
523 #else
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,
528 #endif
529 
530 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
531  Xcp_ClearDaqList_Res,
532  Xcp_SetDaqPtr_Res,
533  Xcp_WriteDaq_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
539  Xcp_GetDaqClock_Res,
540 #else
541  Xcp_CommandNotImplemented_Res,
542 #endif
543 #if XCP_ENABLE_READ_DAQ == XCP_ON
544  Xcp_ReadDaq_Res,
545 #else
546  Xcp_CommandNotImplemented_Res,
547 #endif
548 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON
549  Xcp_GetDaqProcessorInfo_Res,
550 #else
551  Xcp_CommandNotImplemented_Res,
552 #endif
553 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON
554  Xcp_GetDaqResolutionInfo_Res,
555 #else
556  Xcp_CommandNotImplemented_Res,
557 #endif
558 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON
559  Xcp_GetDaqListInfo_Res,
560 #else
561  Xcp_CommandNotImplemented_Res,
562 #endif
563 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON
564  Xcp_GetDaqEventInfo_Res,
565 #else
566  Xcp_CommandNotImplemented_Res,
567 #endif
568 #if XCP_ENABLE_FREE_DAQ == XCP_ON
569  Xcp_FreeDaq_Res,
570 #else
571  Xcp_CommandNotImplemented_Res,
572 #endif
573 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON
574  Xcp_AllocDaq_Res,
575 #else
576  Xcp_CommandNotImplemented_Res,
577 #endif
578 #if XCP_ENABLE_ALLOC_ODT == XCP_ON
579  Xcp_AllocOdt_Res,
580 #else
581  Xcp_CommandNotImplemented_Res,
582 #endif
583 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON
584  Xcp_AllocOdtEntry_Res,
585 #else
586  Xcp_CommandNotImplemented_Res,
587 #endif
588 #else
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,
598 #endif
599 
600 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
601  Xcp_ProgramStart_Res,
602  Xcp_ProgramClear_Res,
603  Xcp_Program_Res,
604  Xcp_ProgramReset_Res,
605 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON
606  Xcp_GetPgmProcessorInfo_Res,
607 #else
608  Xcp_CommandNotImplemented_Res,
609 #endif
610 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON
611  Xcp_GetSectorInfo_Res,
612 #else
613  Xcp_CommandNotImplemented_Res,
614 #endif
615 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON
616  Xcp_ProgramPrepare_Res,
617 #else
618  Xcp_CommandNotImplemented_Res,
619 #endif
620 #if XCP_ENABLE_PROGRAM_FORMAT == XCP_ON
621  Xcp_ProgramFormat_Res,
622 #else
623  Xcp_CommandNotImplemented_Res,
624 #endif
625 #if XCP_ENABLE_PROGRAM_NEXT == XCP_ON
626  Xcp_ProgramNext_Res,
627 #else
628  Xcp_CommandNotImplemented_Res,
629 #endif
630 #if XCP_ENABLE_PROGRAM_MAX == XCP_ON
631  Xcp_ProgramMax_Res,
632 #else
633  Xcp_CommandNotImplemented_Res,
634 #endif
635 #if XCP_ENABLE_PROGRAM_VERIFY == XCP_ON
636  Xcp_ProgramVerify_Res,
637 #else
638  Xcp_CommandNotImplemented_Res,
639 #endif
640 #else
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,
647 #endif
648 #if (XCP_ENABLE_DAQ_COMMANDS == XCP_ON) && \
649  (XCP_ENABLE_WRITE_DAQ_MULTIPLE == XCP_ON)
650  Xcp_WriteDaqMultiple_Res,
651 #else
652  Xcp_CommandNotImplemented_Res,
653 #endif
654  /* lint -restore */
655 };
656 
657 /*
658 ** Global Functions.
659 */
660 void Xcp_Init(void) {
661  Xcp_ConnectionState = XCP_DISCONNECTED;
662 
663  XcpHw_Init();
664  XcpUtl_MemSet(&Xcp_State, UINT8(0), (uint32_t)sizeof(Xcp_StateType));
665  Xcp_State.busy = (bool)XCP_FALSE;
666 
667  Xcp_DefaultResourceProtection();
668 
669 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON
670  Xcp_State.slaveBlockModeState.blockTransferActive = (bool)XCP_FALSE;
671  Xcp_State.slaveBlockModeState.remaining = UINT8(0);
672 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
673 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON
674  Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_FALSE;
675  Xcp_State.masterBlockModeState.remaining = UINT8(0);
676 #endif /* XCP_ENABLE_MASTER_BLOCKMODE */
677 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
678  XcpDaq_Init();
679  Xcp_State.daqProcessor.state = XCP_DAQ_STATE_STOPPED;
680  XcpDaq_SetPointer(0, 0, 0);
681 #endif /* XCP_ENABLE_DAQ_COMMANDS */
682 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
683  Xcp_State.pgmProcessor.state = XCP_PGM_STATE_UNINIT;
684 #endif /* ENABLE_PGM_COMMANDS */
685 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE != 0
686  Xcp_State.counter = (uint16_t)0;
687 #endif /* XCP_TRANSPORT_LAYER_COUNTER_SIZE */
688 
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);
693 #endif /* XCP_ENABLE_STATISTICS */
694  XcpTl_Init();
695 
696 #if (XCP_ENABLE_BUILD_CHECKSUM == XCP_ON) && \
697  (XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_ON)
698  Xcp_ChecksumInit();
699 #endif /* XCP_ENABLE_BUILD_CHECKSUM */
700 }
701 
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;
708 #endif /* XCP_PROTECT_CAL */
709 #if XCP_PROTECT_DAQ == XCP_ON
710  Xcp_State.resourceProtection |= XCP_RESOURCE_DAQ;
711 #endif /* XCP_PROTECT_DAQ */
712 #if XCP_PROTECT_STIM == XCP_ON
713  Xcp_State.resourceProtection |= XCP_RESOURCE_STIM;
714 #endif /* XCP_PROTECT_STIM */
715 #if XCP_PROTECT_PGM == XCP_ON
716  Xcp_State.resourceProtection |= XCP_RESOURCE_PGM;
717 #endif /* XCP_PROTECT_PGM */
718 #endif /* XCP_ENABLE_RESOURCE_PROTECTION */
719 }
720 
721 void Xcp_Disconnect(void) {
722  XcpTl_ReleaseConnection();
723  Xcp_DefaultResourceProtection();
724 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
725  XcpDaq_Init();
726 #endif /* XCP_ENABLE_DAQ_COMMANDS */
727 }
728 
729 void Xcp_MainFunction(void) {
730 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON
731  if (Xcp_SlaveBlockTransferIsActive) {
732  Xcp_UploadSingleBlock();
733  }
734 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
735 
736 #if (XCP_ENABLE_BUILD_CHECKSUM == XCP_ON) && \
737  (XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_ON)
738  Xcp_ChecksumMainFunction();
739 #endif /* (XCP_ENABLE_BUILD_CHECKSUM) && (XCP_CHECKSUM_CHUNKED_CALCULATION == \
740  XCP_ON) */
741  XcpHw_Sleep(XCP_MAIN_FUNCTION_PERIOD);
742 }
743 
744 void Xcp_SetMta(Xcp_MtaType mta) { Xcp_State.mta = mta; }
745 
746 Xcp_MtaType Xcp_GetNonPagedAddress(void const *const ptr) {
747  Xcp_MtaType mta;
748 
749  mta.ext = (uint8_t)0;
750  mta.address = (Xcp_PointerSizeType)ptr;
751  return mta;
752 }
753 
754 void Xcp_SendCto(void) {
755 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE != 0
756  const uint16_t len = Xcp_CtoOut.len;
757 #endif /* XCP_TRANSPORT_LAYER_LENGTH_SIZE */
758 
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);
764 #endif /* XCP_TRANSPORT_LAYER_LENGTH_SIZE */
765 
766 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE == 1
767  Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
768  XCP_LOBYTE(Xcp_State.counter);
769  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);
775  Xcp_State.counter++;
776 #endif /* XCP_TRANSPORT_LAYER_COUNTER_SIZE */
777 
778 #if XCP_ENABLE_STATISTICS == XCP_ON
779  Xcp_State.statistics.crosSend++;
780 #endif /* XCP_ENABLE_STATISTICS */
781 
782  XcpTl_Send(Xcp_CtoOut.data,
783  Xcp_CtoOut.len + (uint16_t)XCP_TRANSPORT_LAYER_BUFFER_OFFSET);
784 }
785 
786 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
787 
788 void Xcp_SendDto(void) {
789 #if XCP_TRANSPORT_LAYER_LENGTH_SIZE != 0
790  const uint16_t len = Xcp_DtoOut.len;
791 #endif /* XCP_TRANSPORT_LAYER_LENGTH_SIZE */
792 
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);
798 #endif /* XCP_TRANSPORT_LAYER_LENGTH_SIZE */
799 
800 #if XCP_TRANSPORT_LAYER_COUNTER_SIZE == 1
801  Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_LENGTH_SIZE] =
802  XCP_LOBYTE(Xcp_State.counter);
803  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);
809  Xcp_State.counter++;
810 #endif /* XCP_TRANSPORT_LAYER_COUNTER_SIZE */
811 
812 #if XCP_ENABLE_STATISTICS == XCP_ON
813  Xcp_State.statistics.crosSend++;
814 #endif /* XCP_ENABLE_STATISTICS */
815 
816  XcpTl_Send(Xcp_DtoOut.data,
817  Xcp_DtoOut.len + (uint16_t)XCP_TRANSPORT_LAYER_BUFFER_OFFSET);
818 }
819 
820 uint8_t *Xcp_GetDtoOutPtr(void) {
821  return &(Xcp_DtoOut.data[XCP_TRANSPORT_LAYER_BUFFER_OFFSET]);
822 }
823 
824 void Xcp_SetDtoOutLen(uint16_t len) { Xcp_DtoOut.len = len; }
825 
826 #endif /* XCP_ENABLE_DAQ_COMMANDS */
827 
828 uint8_t *Xcp_GetCtoOutPtr(void) {
829  return &(Xcp_CtoOut.data[XCP_TRANSPORT_LAYER_BUFFER_OFFSET]);
830 }
831 
832 void Xcp_SetCtoOutLen(uint16_t len) { Xcp_CtoOut.len = len; }
833 
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();
837 
838 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON
839  len = XCP_MAX_CTO;
840 #endif /* XCP_ON_CAN_MAX_DLC_REQUIRED */
841 
842  Xcp_SetCtoOutLen(UINT16(len));
843 
844  /* MISRA 2004 violation Rule 15.2 */
845  /* Controlled fall-through (copy optimization) */
846  switch (len) {
847  case 8:
848  dataOut[7] = b7;
849  /*lint -fallthrough */
850  //[[fallthrough]];
851  case 7:
852  dataOut[6] = b6;
853  /*lint -fallthrough */
854  //[[fallthrough]];
855  case 6:
856  dataOut[5] = b5;
857  /*lint -fallthrough */
858  //[[fallthrough]];
859  case 5:
860  dataOut[4] = b4;
861  /*lint -fallthrough */
862  //[[fallthrough]];
863  case 4:
864  dataOut[3] = b3;
865  /*lint -fallthrough */
866  //[[fallthrough]];
867  case 3:
868  dataOut[2] = b2;
869  /*lint -fallthrough */
870  //[[fallthrough]];
871  case 2:
872  dataOut[1] = b1;
873  /*lint -fallthrough */
874  //[[fallthrough]];
875  case 1:
876  dataOut[0] = b0;
877  break;
878  default:
879  break;
880  }
881 
882  Xcp_SendCto();
883 }
884 
885 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON
886 XCP_STATIC bool Xcp_SlaveBlockTransferIsActive(void) {
887  return Xcp_State.slaveBlockModeState.blockTransferActive;
888 }
889 
890 XCP_STATIC void Xcp_SlaveBlockTransferSetActive(bool onOff) {
891  XCP_ENTER_CRITICAL();
892  Xcp_SetBusy(onOff); /* Active slave block-mode also means command processor is
893  busy. */
894  Xcp_State.slaveBlockModeState.blockTransferActive = onOff;
895  XCP_LEAVE_CRITICAL();
896 }
897 
898 void Xcp_UploadSingleBlock(void) {
899  uint8_t *dataOut = XCP_NULL;
900  uint8_t length = UINT8(0x00);
901  Xcp_MtaType dst = {0};
902 
903  if (!Xcp_SlaveBlockTransferIsActive()) {
904  return;
905  }
906  dataOut = Xcp_GetCtoOutPtr();
907  dataOut[0] = (uint8_t)ERR_SUCCESS;
908  dst.address = (Xcp_PointerSizeType)(dataOut + 1);
909  dst.ext = (uint8_t)0;
910 
911  if (Xcp_State.slaveBlockModeState.remaining <= (XCP_MAX_CTO - 1)) {
912  length = Xcp_State.slaveBlockModeState.remaining;
913 
914 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON
915  Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
916 #else
917  Xcp_SetCtoOutLen(length + UINT16(1));
918 #endif /* XCP_ON_CAN_MAX_DLC_REQUIRED */
919 
920  // printf("PART BLOCK: %08x LEN% 02x\n", Xcp_State.mta.address, length);
921  Xcp_CopyMemory(dst, Xcp_State.mta, (uint32_t)length);
922  XCP_INCREMENT_MTA(length);
923  Xcp_State.slaveBlockModeState.remaining -= length;
924  } else {
925  Xcp_SetCtoOutLen(UINT16(XCP_MAX_CTO));
926  // printf("FULL BLOCK: %08x\n", Xcp_State.mta.address);
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);
930  }
931 
932  Xcp_SendCto();
933  if (Xcp_State.slaveBlockModeState.remaining == UINT8(0)) {
934  Xcp_SlaveBlockTransferSetActive((bool)XCP_FALSE);
935  // printf("FINISHED.\n");
936  // printf("----------------------------------------\n");
937  }
938 }
939 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
940 
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;
948 
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));
953 #else
954  Xcp_SetCtoOutLen(len + UINT16(1));
955 #endif /* XCP_ON_CAN_MAX_DLC_REQUIRED */
956  Xcp_SendCto();
957 #else
958  Xcp_State.slaveBlockModeState.remaining = len;
959 
960  // printf("----------------------------------------\n");
961  Xcp_SlaveBlockTransferSetActive((bool)XCP_TRUE);
962  Xcp_UploadSingleBlock();
963 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
964 }
965 
972 void Xcp_DispatchCommand(Xcp_PduType const *const pdu) {
973  const uint8_t cmd = pdu->data[0];
974  DBG_TRACE1("<- ");
975 
976  if (Xcp_State.connected == (bool)XCP_TRUE) {
977  /*DBG_PRINT2("CMD: [%02X]\n\r", cmd); */
978 
979  if (Xcp_IsBusy()) {
980  Xcp_BusyResponse();
981  return;
982  } else {
983 #if XCP_ENABLE_STATISTICS == XCP_ON
984  Xcp_State.statistics.ctosReceived++;
985 #endif /* XCP_ENABLE_STATISTICS */
986  Xcp_ServerCommands[UINT8(0xff) - cmd](pdu);
987  }
988  } else { /* not connected. */
989 #if XCP_ENABLE_STATISTICS == XCP_ON
990  Xcp_State.statistics.ctosReceived++;
991 #endif /* XCP_ENABLE_STATISTICS */
992  if (pdu->data[0] == UINT8(XCP_CONNECT)) {
993  Xcp_Connect_Res(pdu);
994  } else {
995  }
996  }
997 #if defined(_MSC_VER)
998  fflush(stdout);
999 #endif
1000 }
1001 
1002 void Xcp_SetSendCallout(Xcp_SendCalloutType callout) {
1003  Xcp_SendCallout = callout;
1004 }
1005 
1006 /*
1007 **
1008 ** Global Helper Functions.
1009 **
1010 ** Note: These functions are only useful for unit-testing and debugging.
1011 **
1012 */
1013 Xcp_ConnectionStateType Xcp_GetConnectionState(void) {
1014  return Xcp_ConnectionState;
1015 }
1016 
1017 /*
1018 **
1019 ** Local Functions.
1020 **
1021 */
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));
1025 }
1026 
1027 XCP_STATIC void Xcp_Connect_Res(Xcp_PduType const *const pdu) {
1028  uint8_t resource = UINT8(0x00);
1029  uint8_t commModeBasic = UINT8(0x00);
1030 
1031  DBG_TRACE1("CONNECT\n\r");
1032 
1033  if (Xcp_State.connected == (bool)XCP_FALSE) {
1034  Xcp_State.connected = (bool)XCP_TRUE;
1035  /* TODO: Init stuff */
1036  }
1037 
1038 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
1039  resource |= XCP_RESOURCE_PGM;
1040 #endif /* XCP_ENABLE_PGM_COMMANDS */
1041 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
1042  resource |= XCP_RESOURCE_DAQ;
1043 #endif /* XCP_ENABLE_DAQ_COMMANDS */
1044 #if (XCP_ENABLE_CAL_COMMANDS == XCP_ON) || (XCP_ENABLE_PAG_COMMANDS == XCP_ON)
1045  resource |= XCP_RESOURCE_CAL_PAG;
1046 #endif
1047 #if XCP_ENABLE_STIM == XCP_ON
1048  resource |= XCP_RESOURCE_STIM;
1049 #endif /* XCP_ENABLE_STIM */
1050 
1051  commModeBasic |= XCP_BYTE_ORDER;
1052  commModeBasic |= XCP_ADDRESS_GRANULARITY;
1053 #if XCP_ENABLE_SLAVE_BLOCKMODE == XCP_ON
1054  commModeBasic |= XCP_SLAVE_BLOCK_MODE;
1055 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
1056 #if XCP_ENABLE_GET_COMM_MODE_INFO
1057  commModeBasic |= XCP_OPTIONAL_COMM_MODE;
1058 #endif /* XCP_ENABLE_GET_COMM_MODE_INFO */
1059 
1060  XcpTl_SaveConnection();
1061 
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));
1066  /*DBG_PRINT("MAX-DTO: %04X H: %02X L: %02X\n\r", XCP_MAX_DTO,
1067  * HIBYTE(XCP_MAX_DTO), LOBYTE(XCP_MAX_DTO)); */
1068 }
1069 
1070 XCP_STATIC void Xcp_Disconnect_Res(Xcp_PduType const *const pdu) {
1071  DBG_TRACE1("DISCONNECT\n\r\n\r");
1072 
1073  XCP_ASSERT_PGM_IDLE();
1074  Xcp_PositiveResponse();
1075  Xcp_Disconnect();
1076 }
1077 
1078 XCP_STATIC void Xcp_GetStatus_Res(Xcp_PduType const *const pdu) {
1079  DBG_TRACE1("GET_STATUS\n\r");
1080 
1081  Xcp_Send8(
1082  UINT8(6), UINT8(XCP_PACKET_IDENTIFIER_RES),
1083  UINT8(0), /* Current session status */
1084 #if XCP_ENABLE_RESOURCE_PROTECTION == XCP_ON
1085  Xcp_State.resourceProtection, /* Current resource protection status */
1086 #else
1087  UINT8(0x00), /* Everything is unprotected. */
1088 #endif /* XCP_ENABLE_RESOURCE_PROTECTION */
1089  UINT8(0x00), /* Reserved */
1090  UINT8(0), /* Session configuration id */
1091  UINT8(0), /* " " */
1092  UINT8(0), UINT8(0));
1093 }
1094 
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));
1098 }
1099 
1100 #if XCP_ENABLE_GET_COMM_MODE_INFO == XCP_ON
1101 
1102 XCP_STATIC void Xcp_GetCommModeInfo_Res(Xcp_PduType const *const pdu) {
1103  uint8_t commModeOptional = UINT8(0);
1104 
1105  DBG_TRACE1("GET_COMM_MODE_INFO\n\r");
1106 
1107 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON
1108  commModeOptional |= XCP_MASTER_BLOCK_MODE;
1109 #endif /* XCP_ENABLE_MASTER_BLOCKMODE */
1110 
1111 #if XCP_ENABLE_INTERLEAVED_MODE == XCP_ON
1112  commModeOptional |= XCP_INTERLEAVED_MODE;
1113 #endif /* XCP_ENABLE_INTERLEAVED_MODE */
1114 
1115  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0), /* Reserved */
1116  commModeOptional, UINT8(0), /* Reserved */
1117  UINT8(XCP_MAX_BS), UINT8(XCP_MIN_ST), UINT8(XCP_QUEUE_SIZE),
1118  UINT8(XCP_DRIVER_VERSION));
1119 }
1120 
1121 #endif /* XCP_ENABLE_GET_COMM_MODE_INFO */
1122 
1123 #if XCP_ENABLE_GET_ID == XCP_ON
1124 
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;
1130 
1131  DBG_TRACE2("GET_ID [type: 0x%02x]\n\r", idType);
1132 
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;
1139  }
1140 #if XCP_ENABLE_GET_ID_HOOK == XCP_ON
1141  else {
1142  if (!Xcp_HookFunction_GetId(idType, &response, &response_len)) {
1143  response_len = 0;
1144  valid = XCP_FALSE;
1145  }
1146  }
1147 #else
1148  else {
1149  response_len = 0;
1150  valid = XCP_FALSE;
1151  }
1152 #endif /* XCP_ENABLE_GET_ID_HOOK */
1153  if (valid) {
1154  Xcp_SetMta(Xcp_GetNonPagedAddress(response));
1155  }
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)));
1161 }
1162 
1163 #endif /* XCP_ENABLE_GET_ID */
1164 
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();
1172 
1173  DBG_TRACE3("GET_SEED [mode: %02x resource: %02x]\n\r", mode, resource);
1174 
1175  XCP_ASSERT_PGM_IDLE();
1176  switch (resource) {
1177  case XCP_RESOURCE_PGM:
1178 #if XCP_ENABLE_PGM_COMMANDS == XCP_OFF
1179  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1180  return;
1181 #else
1182  break;
1183 #endif /* XCP_ENABLE_PGM_COMMANDS */
1184  case XCP_RESOURCE_STIM:
1185 #if XCP_ENABLE_STIM == XCP_OFF
1186  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1187  return;
1188 #else
1189  break;
1190 #endif /* XCP_ENABLE_STIM */
1191  case XCP_RESOURCE_DAQ:
1192 #if XCP_ENABLE_DAQ_COMMANDS == XCP_OFF
1193  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1194  return;
1195 #else
1196  break;
1197 #endif /* XCP_ENABLE_DAQ_COMMANDS */
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));
1201  return;
1202 #else
1203  break;
1204 #endif /* XCP_ENABLE_CAL_COMMANDS */
1205  default:
1206  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1207  return;
1208  }
1209 
1210  if (Xcp_IsProtected(resource)) {
1211  Xcp_HookFunction_GetSeed(resource, &seed); /* User supplied callout. */
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);
1215  } else {
1216  /* Resource already unlocked. */
1217  length = UINT8(0);
1218  }
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));
1224 #else
1225  Xcp_SetCtoOutLen(length + UINT16(2));
1226 #endif /* XCP_ON_CAN_MAX_DLC_REQUIRED */
1227  Xcp_SendCto();
1228 }
1229 #endif /* XCP_ENABLE_GET_SEED */
1230 
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};
1235 
1236  DBG_TRACE2("UNLOCK [length: %u]\n\r", length);
1237 
1238  XCP_ASSERT_PGM_IDLE();
1239  if (Xcp_State.seedRequested == UINT8(0)) {
1240  Xcp_ErrorResponse(UINT8(ERR_SEQUENCE));
1241  return;
1242  }
1243 
1244  key.length = length;
1245  key.data = pdu->data + 2;
1246 
1247  if (Xcp_HookFunction_Unlock(Xcp_State.seedRequested,
1248  &key)) { /* User supplied callout. */
1249  Xcp_State.resourceProtection &=
1250  UINT8(~(Xcp_State.seedRequested)); /* OK, unlock. */
1251  Xcp_Send8(
1252  UINT8(2), UINT8(XCP_PACKET_IDENTIFIER_RES),
1253  Xcp_State.resourceProtection, /* Current resource protection status. */
1254  UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
1255 
1256  } else {
1257  Xcp_ErrorResponse(UINT8(ERR_ACCESS_LOCKED));
1258  Xcp_Disconnect();
1259  }
1260  Xcp_State.seedRequested = UINT8(0x00);
1261 }
1262 #endif /* XCP_ENABLE_UNLOCK */
1263 
1264 #if XCP_ENABLE_UPLOAD == XCP_ON
1265 
1266 XCP_STATIC void Xcp_Upload_Res(Xcp_PduType const *const pdu) {
1267  uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1268 
1269  DBG_TRACE2("UPLOAD [len: %u]\n\r", len);
1270 
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));
1276  return;
1277  }
1278 #else
1279 
1280 #endif /* XCP_ENABLE_SLAVE_BLOCKMODE */
1281 
1282  Xcp_Upload(len);
1283 }
1284 
1285 #endif /* XCP_ENABLE_UPLOAD */
1286 
1287 #if XCP_ENABLE_SHORT_UPLOAD == XCP_ON
1288 
1289 XCP_STATIC void Xcp_ShortUpload_Res(Xcp_PduType const *const pdu) {
1290  uint8_t len = Xcp_GetByte(pdu, UINT8(1));
1291 
1292  DBG_TRACE2("SHORT-UPLOAD [len: %u]\n\r", len);
1293 
1294  XCP_ASSERT_PGM_IDLE();
1295  XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_READ,
1296  (bool)XCP_FALSE);
1297  if (len > UINT8(XCP_MAX_CTO - 1)) {
1298  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1299  return;
1300  }
1301 
1302  Xcp_State.mta.ext = Xcp_GetByte(pdu, UINT8(3));
1303  Xcp_State.mta.address = Xcp_GetDWord(pdu, UINT8(4));
1304  Xcp_Upload(len);
1305 }
1306 
1307 #endif /* XCP_ENABLE_SHORT_UPLOAD */
1308 
1309 #if XCP_ENABLE_SET_MTA == XCP_ON
1310 
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));
1314 
1315  DBG_TRACE3("SET_MTA [address: 0x%08x ext: 0x%02x]\n\r", Xcp_State.mta.address,
1316  Xcp_State.mta.ext);
1317 
1318  Xcp_PositiveResponse();
1319 }
1320 
1321 #endif /* XCP_ENABLE_SET_MTA */
1322 
1323 #if XCP_ENABLE_BUILD_CHECKSUM == XCP_ON
1324 
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)));
1330 }
1331 
1332 void Xcp_SendChecksumOutOfRangeResponse(void) {
1333  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_ERR), UINT8(ERR_OUT_OF_RANGE),
1334  UINT8(0), UINT8(0),
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)));
1339 }
1340 
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;
1345 
1346  DBG_TRACE2("BUILD_CHECKSUM [blocksize: %u]\n\r", blockSize);
1347 
1348  XCP_ASSERT_PGM_IDLE();
1349  XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, blockSize, XCP_MEM_ACCESS_READ,
1350  (bool)XCP_FALSE);
1351 #if XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE > 0
1352  /* We need to range check. */
1353  if (blockSize > UINT32(XCP_CHECKSUM_MAXIMUM_BLOCK_SIZE)) {
1354  Xcp_SendChecksumOutOfRangeResponse();
1355  return;
1356  }
1357 #endif
1358 
1359  ptr = (uint8_t const *)Xcp_State.mta.address;
1360  /* The MTA will be post-incremented by the block size. */
1361 
1362 #if XCP_CHECKSUM_CHUNKED_CALCULATION == XCP_OFF
1363  checksum =
1364  Xcp_CalculateChecksum(ptr, blockSize, (Xcp_ChecksumType)0, XCP_TRUE);
1365  Xcp_SendChecksumPositiveResponse(checksum);
1366 #else
1367  if (blockSize <= UINT32(XCP_CHECKSUM_CHUNK_SIZE)) {
1368  checksum = Xcp_CalculateChecksum(ptr, blockSize, (Xcp_ChecksumType)0,
1369  (bool)XCP_TRUE);
1370  Xcp_SendChecksumPositiveResponse(checksum);
1371  } else {
1372  Xcp_StartChecksumCalculation(ptr, blockSize);
1373  }
1374 #endif /* XCP_CHECKSUM_CHUNKED_CALCULATION */
1375 }
1376 
1377 #endif /* XCP_ENABLE_BUILD_CHECKSUM */
1378 
1379 #if 0
1380 XCP_VALIDATE_ADRESS
1381  Callout der die gültigkeit eines Speicherzugriffs überprüft [addr;length]
1382 #endif
1383 
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);
1388 }
1389 #endif /* XCP_ENABLE_TRANSPORT_LAYER_CMD */
1390 
1391 #if XCP_ENABLE_USER_CMD
1392 XCP_STATIC void Xcp_UserCmd_Res(Xcp_PduType const *const pdu) {
1393  XCP_ASSERT_PGM_IDLE();
1394 }
1395 #endif /* XCP_ENABLE_USER_CMD */
1396 
1397 /*
1398 **
1399 ** CAL Commands.
1400 **
1401 */
1402 #if XCP_ENABLE_CAL_COMMANDS == XCP_ON
1403 
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);
1408 
1409  XCP_ASSERT_PGM_IDLE();
1410  XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_WRITE, XCP_FALSE);
1411 
1412 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_ON
1413  Xcp_State.masterBlockModeState.blockTransferActive = (bool)XCP_FALSE;
1414  if (len > LIMIT) {
1415  Xcp_ErrorResponse(ERR_OUT_OF_RANGE); /* Request exceeds max. block size. */
1416  return;
1417  } else if (len > XCP_DOWNLOAD_PAYLOAD_LENGTH) {
1418  /* OK, regular first-frame transfer. */
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));
1424  return;
1425  }
1426 #endif /* XCP_ENABLE_MASTER_BLOCKMODE */
1427 
1428 #if XCP_ENABLE_MASTER_BLOCKMODE == XCP_OFF
1429  if (len > XCP_DOWNLOAD_PAYLOAD_LENGTH) {
1430  Xcp_ErrorResponse(
1431  ERR_OUT_OF_RANGE); /* Request exceeds max. payload size. */
1432  return;
1433  }
1434 #endif
1435  Xcp_Download_Copy(UINT32(pdu->data + 2), UINT8(0), UINT32(len));
1436  Xcp_PositiveResponse();
1437 }
1438 
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));
1443  uint8_t len;
1444  Xcp_MtaType src = {0};
1445 
1446  DBG_TRACE2("DOWNLOAD_NEXT [remaining: %u]\n\r", remaining);
1447 
1448  XCP_ASSERT_PGM_IDLE();
1449  if (!Xcp_State.masterBlockModeState.blockTransferActive) {
1450  Xcp_ErrorResponse(
1451  ERR_SEQUENCE); /* Check: Is it really necessary to start a block-mode
1452  transfer with Xcp_Download_Res? */
1453  return;
1454  }
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();
1461  }
1462 }
1463 #endif /* XCP_ENABLE_MASTER_BLOCKMODE */
1464 #endif /* XCP_ENABLE_DOWNLOAD_NEXT */
1465 
1466 #if XCP_ENABLE_DOWNLOAD_MAX == XCP_ON
1467 
1468 XCP_STATIC void Xcp_DownloadMax_Res(Xcp_PduType const *const pdu) {
1469  Xcp_MtaType src = {0};
1470 
1471  DBG_TRACE1("DOWNLOAD_MAX\n\r");
1472 
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();
1477 }
1478 
1479 #endif /* XCP_ENABLE_DOWNLOAD_MAX */
1480 
1481 #if XCP_ENABLE_SHORT_DOWNLOAD == XCP_ON
1482 
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};
1489 
1490  DBG_TRACE4("SHORT-DOWNLOAD [len: %u address: 0x%08x ext: 0x%02x]\n\r", len,
1491  address, addrExt);
1492  dst.address = address;
1493  dst.ext = addrExt;
1494 
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));
1499  return;
1500  }
1501 
1502  src.address = (Xcp_PointerSizeType)pdu->data + 8;
1503  src.ext = UINT8(0);
1504  Xcp_CopyMemory(dst, src, (uint32_t)len);
1505 
1506  XCP_INCREMENT_MTA(len);
1507 
1508  Xcp_PositiveResponse();
1509 }
1510 
1511 #endif /* XCP_ENABLE_SHORT_DOWNLOAD */
1512 
1513 #if XCP_ENABLE_MODIFY_BITS == XCP_ON
1514 
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;
1520 
1521  DBG_TRACE4("MODIFY-BITS [shiftValue: 0x%02X andMask: 0x%04x ext: xorMask: "
1522  "0x%04x]\n\r",
1523  shiftValue, andMask, xorMask);
1524  XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, 2, XCP_MEM_ACCESS_WRITE,
1525  (bool)XCP_FALSE);
1526  vp = (uint32_t *)Xcp_State.mta.address;
1527  *vp = ((*vp) & ((~((uint32_t)(((uint16_t)~andMask) << shiftValue))) ^
1528  ((uint32_t)(xorMask << shiftValue))));
1529 
1530  Xcp_PositiveResponse();
1531 }
1532 
1533 #endif /* XCP_ENABLE_MODIFY_BITS */
1534 
1535 #endif /* XCP_ENABLE_CAL_COMMANDS */
1536 
1537 /*
1538 **
1539 ** DAQ Commands.
1540 **
1541 */
1542 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
1543 
1544 XCP_STATIC void Xcp_ClearDaqList_Res(Xcp_PduType const *const pdu) {
1545  XcpDaq_ListIntegerType daqListNumber = (XcpDaq_ListIntegerType)0;
1546 
1547  daqListNumber = (XcpDaq_ListIntegerType)Xcp_GetWord(pdu, UINT8(2));
1548 
1549  DBG_TRACE2("CLEAR_DAQ_LIST [daq: %u] \n\r", daqListNumber);
1550 
1551  XCP_ASSERT_PGM_IDLE();
1552  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1553  Xcp_PositiveResponse();
1554 }
1555 
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;
1560 
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));
1567 
1568  /* TODO: Check for Predef. lists only */
1569 
1570  if (!XcpDaq_ValidateOdtEntry(daqList, odt, odtEntry)) {
1571  /* If the specified list is not available, ERR_OUT_OF_RANGE will be
1572  * returned. */
1573  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1574  return;
1575  }
1576 
1577  XcpDaq_SetPointer(daqList, odt, odtEntry);
1578 
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);
1582 
1583  Xcp_PositiveResponse();
1584 }
1585 
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));
1591 
1592  DBG_TRACE1("WRITE_DAQ\n\r");
1593 
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
1598  /* WRITE_DAQ is only possible for elements in configurable DAQ lists. */
1599  if (Xcp_State.daqPointer.daqList < XcpDaq_PredefinedListCount) {
1600  Xcp_SendResult(ERR_WRITE_PROTECTED);
1601  return;
1602  }
1603 #endif /* XCP_DAQ_ENABLE_PREDEFINED_LISTS */
1604  Xcp_WriteDaqEntry(bitOffset, elemSize, adddrExt, address);
1605  Xcp_PositiveResponse();
1606 }
1607 
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);
1617 
1618  if (((numElements * UINT8(8)) + UINT8(2)) > XCP_MAX_CTO) {
1619  // To many ODT entries to fit into one XCP frame.
1620  Xcp_SendResult(ERR_OUT_OF_RANGE);
1621  return;
1622  }
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
1628  /* WRITE_DAQ is only possible for elements in configurable DAQ lists. */
1629  if (Xcp_State.daqPointer.daqList < XcpDaq_PredefinedListCount) {
1630  Xcp_SendResult(ERR_WRITE_PROTECTED);
1631  return;
1632  }
1633 #endif /* XCP_DAQ_ENABLE_PREDEFINED_LISTS */
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);
1641  }
1642  Xcp_PositiveResponse();
1643 }
1644 #endif // XCP_ENABLE_WRITE_DAQ_MULTIPLE
1645 
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));
1654 
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);
1661 
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));
1665  return;
1666  }
1667 #endif /* XCP_ENABLE_STIM */
1668 /*
1669 The master is not allowed to set the ALTERNATING flag and the TIMESTAMP flag at
1670 the same time.
1671 */
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));
1675  return;
1676  }
1677 #endif /* XCP_DAQ_ENABLE_ALTERNATING */
1678 #if XCP_DAQ_PRIORITIZATION_SUPPORTED == XCP_OFF
1679  /* Needs to be 0 */
1680  if (priority > UINT8(0)) {
1681  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1682  return;
1683  }
1684 #endif /* XCP_DAQ_ENABLE_PRIORITIZATION */
1685 #if XCP_DAQ_PRESCALER_SUPPORTED == XCP_OFF
1686  /* Needs to be 1 */
1687  if (prescaler > UINT8(1)) {
1688  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1689  return;
1690  }
1691 #endif /* XCP_DAQ_ENABLE_PRESCALER */
1692 
1693  entry = XcpDaq_GetListState(daqListNumber);
1694  XcpDaq_AddEventChannel(daqListNumber, eventChannelNumber);
1695 
1696  entry->mode =
1697  Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_TIMESTAMP);
1698  entry->mode =
1699  Xcp_SetResetBit8(entry->mode, mode, XCP_DAQ_LIST_MODE_ALTERNATING);
1700  entry->mode =
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;
1707 #endif /* XCP_DAQ_ENABLE_PRESCALER */
1708 
1709  Xcp_PositiveResponse();
1710 }
1711 
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));
1718 
1719  DBG_TRACE3("START_STOP_DAQ_LIST [mode: 0x%02x daq: %03u]\n\r", mode,
1720  daqListNumber);
1721  XCP_ASSERT_PGM_IDLE();
1722  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1723 
1724  if (daqListNumber >= XcpDaq_GetListCount()) {
1725  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1726  }
1727 
1728  entry = XcpDaq_GetListState(daqListNumber);
1729 
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;
1734  } else {
1735  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE)); /* correct? */
1736  return;
1737  }
1738 
1739  XcpDaq_GetFirstPid(daqListNumber, &firstPid);
1740 
1741  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), firstPid, UINT8(0),
1742  UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
1743 }
1744 
1745 XCP_STATIC void Xcp_StartStopSynch_Res(Xcp_PduType const *const pdu) {
1746  const uint8_t mode = Xcp_GetByte(pdu, UINT8(1));
1747 
1748  DBG_TRACE2("START_STOP_SYNCH [mode: 0x%02x]\n\r", mode);
1749  XCP_ASSERT_PGM_IDLE();
1750  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1751 
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();
1760  } else {
1761  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1762  return;
1763  }
1764  Xcp_PositiveResponse();
1765 }
1766 
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();
1772 }
1773 
1774 #if XCP_ENABLE_GET_DAQ_PROCESSOR_INFO == XCP_ON
1775 
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;
1779 
1780  DBG_TRACE1("GET_DAQ_PROCESSOR_INFO\n\r");
1781  XCP_ASSERT_PGM_IDLE();
1782  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1783 
1784  XcpDaq_GetProperties(&properties);
1785  listCount = XcpDaq_GetListCount();
1786 
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,
1793 #else
1794  UINT8(0),
1795 #endif /* XCP_DAQ_ENABLE_PREDEFINED_LISTS */
1796  UINT8(0));
1797 }
1798 
1799 #endif /* XCP_ENABLE_GET_DAQ_PROCESSOR_INFO */
1800 
1801 #if XCP_ENABLE_GET_DAQ_LIST_INFO == XCP_ON
1802 
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;
1807  /* XcpDaq_ListStateType * listState = XCP_NULL;*/
1808  uint8_t properties = UINT8(0x00);
1809 
1810  DBG_TRACE2("GET_DAQ_LIST_INFO [daq: %u] \n\r", daqListNumber);
1811  XCP_ASSERT_PGM_IDLE();
1812  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1813 
1814  if (daqListNumber >= XcpDaq_GetListCount()) {
1815  Xcp_ErrorResponse(UINT8(ERR_OUT_OF_RANGE));
1816  }
1817 
1818  listConf = XcpDaq_GetListConfiguration(daqListNumber);
1819  /* listState = XcpDaq_GetListState(daqListNumber); */
1820 
1821  properties |= DAQ_LIST_PROPERTY_PREDEFINED; /* Hardcoded for now. */
1822  properties |= DAQ_LIST_PROPERTY_EVENT_FIXED; /* " " */
1823  properties |= DAQ_LIST_PROPERTY_DAQ; /* " " */
1824 
1825 #if XCP_DAQ_ENABLE_PREDEFINED_LISTS == XCP_ON
1826  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES), properties,
1827  listConf->numOdts, 0, /* Hardcoded for now. */
1828  0, /* Hardcoded for now. */
1829  UINT8(0), UINT8(0), UINT8(0));
1830 #else
1831  Xcp_ErrorResponse(UINT8(ERR_CMD_SYNTAX));
1832 #endif /* XCP_DAQ_ENABLE_PREDEFINED_LISTS */
1833 }
1834 
1835 #endif /* XCP_ENABLE_GET_DAQ_LIST_INFO */
1836 
1837 #if XCP_ENABLE_FREE_DAQ == XCP_ON
1838 
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());
1844 }
1845 
1846 #endif /* XCP_ENABLE_FREE_DAQ */
1847 
1848 #if XCP_ENABLE_ALLOC_DAQ == XCP_ON
1849 
1850 XCP_STATIC void Xcp_AllocDaq_Res(Xcp_PduType const *const pdu) {
1851  XcpDaq_ListIntegerType daqCount = (XcpDaq_ListIntegerType)0;
1852 
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));
1858 }
1859 
1860 #endif
1861 
1862 #if XCP_ENABLE_ALLOC_ODT == XCP_ON
1863 
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;
1867 
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));
1874 }
1875 
1876 #endif /* XCP_ENABLE_ALLOC_ODT */
1877 
1878 #if XCP_ENABLE_ALLOC_ODT_ENTRY == XCP_ON
1879 
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;
1884 
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);
1892  Xcp_SendResult(
1893  XcpDaq_AllocOdtEntry(daqListNumber, odtNumber, odtEntriesCount));
1894 }
1895 
1896 #endif /* XCP_ENABLE_ALLOC_ODT_ENTRY */
1897 
1898 #if XCP_ENABLE_GET_DAQ_CLOCK == XCP_ON
1899 
1900 XCP_STATIC void Xcp_GetDaqClock_Res(Xcp_PduType const *const pdu) {
1901  uint32_t timestamp = UINT32(0);
1902 
1903  XCP_ASSERT_PGM_IDLE();
1904 #if XCP_DAQ_CLOCK_ACCESS_ALWAYS_SUPPORTED == XCP_OFF
1905  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1906 #endif /* XCP_DAQ_ENABLE_CLOCK_ACCESS_ALWAYS */
1907 
1908  timestamp = XcpHw_GetTimerCounter();
1909  DBG_TRACE2("GET_DAQ_CLOCK [timestamp: %u]\n\r", timestamp);
1910  Xcp_Send8(
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)));
1914 }
1915 
1916 #endif /* XCP_ENABLE_GET_DAQ_CLOCK */
1917 
1918 #if XCP_ENABLE_GET_DAQ_RESOLUTION_INFO == XCP_ON
1919 
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);
1924 
1925  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES),
1926  UINT8(1), /* Granularity for size of ODT entry (DIRECTION = DAQ) */
1927  UINT8(XCP_DAQ_MAX_ODT_ENTRY_SIZE), /* Maximum size of ODT entry
1928  (DIRECTION = DAQ) */
1929  UINT8(1), /* Granularity for size of ODT entry (DIRECTION = STIM) */
1930  UINT8(XCP_DAQ_MAX_ODT_ENTRY_SIZE), /* Maximum size of ODT entry
1931  (DIRECTION = STIM) */
1932  UINT8(0x34), /* Timestamp unit and size */
1933  UINT8(1), /* Timestamp ticks per unit (WORD) */
1934  UINT8(0));
1935 }
1936 
1937 #endif /* XCP_ENABLE_GET_DAQ_RESOLUTION_INFO */
1938 
1939 #if XCP_ENABLE_GET_DAQ_EVENT_INFO == XCP_ON
1940 
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;
1945 
1946  DBG_TRACE2("GET_DAQ_EVENT_INFO [eventChannel: %d]\n\r", eventChannel);
1947  XCP_ASSERT_UNLOCKED(XCP_RESOURCE_DAQ);
1948 
1949  if (eventChannel >= UINT8(XCP_DAQ_MAX_EVENT_CHANNEL)) {
1950  Xcp_SendResult(ERR_OUT_OF_RANGE);
1951  return;
1952  }
1953  event = XcpDaq_GetEventConfiguration(eventChannel);
1954  if ((event->name == XCP_NULL) || (event->nameLen == UINT8(0))) {
1955  nameLen = UINT8(0);
1956  } else {
1957  nameLen = event->nameLen;
1958  Xcp_SetMta(Xcp_GetNonPagedAddress(event->name));
1959  }
1960 
1961  Xcp_Send8(UINT8(7), UINT8(XCP_PACKET_IDENTIFIER_RES),
1962  UINT8(event->properties), /* DAQ_EVENT_PROPERTIES */
1963  UINT8(1), /* maximum number of DAQ lists in this event channel */
1964  UINT8(nameLen), /* EVENT_CHANNEL_NAME_LENGTH in bytes 0 – If not
1965  available */
1966  UINT8(event->cycle), /* EVENT_CHANNEL_TIME_CYCLE 0 – Not cyclic */
1967  UINT8(event->timeunit), /* EVENT_CHANNEL_TIME_UNIT don’t care if
1968  Event channel time cycle = 0 */
1969  UINT8(0), /* EVENT_CHANNEL_PRIORITY (FF highest) */
1970  UINT8(0));
1971 }
1972 
1973 #endif /* XCP_ENABLE_GET_DAQ_EVENT_INFO */
1974 
1975 #endif /* XCP_ENABLE_DAQ_COMMANDS */
1976 
1977 /*
1978 **
1979 ** PGM Services.
1980 **
1981 */
1982 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
1983 
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);
1989 
1990  Xcp_Send8(
1991  UINT8(7), UINT8(XCP_PACKET_IDENTIFIER_RES), UINT8(0), /* Reserved */
1992  UINT8(0), /* COMM_MODE_PGM */
1993  UINT8(XCP_MAX_CTO), /* MAX_CTO_PGM [BYTES]Maximum CTO size for PGM */
1994  UINT8(XCP_MAX_BS_PGM), /* MAX_BS_PGM */
1995  UINT8(XCP_MIN_ST_PGM), /* MIN_ST_PGM */
1996  UINT8(0), /* QUEUE_SIZE_PGM */
1997  UINT8(0));
1998 }
1999 
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));
2003 
2004  DBG_TRACE3("PROGRAM_CLEAR [mode: %d clearRange: 0x%08x]\n\r", mode,
2005  clearRange);
2006  XCP_ASSERT_PGM_ACTIVE();
2007 
2008  Xcp_PositiveResponse();
2009 }
2010 
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};
2014 
2015  DBG_TRACE2("PROGRAM [len: %u]\n\r", len);
2016 
2017  XCP_ASSERT_PGM_ACTIVE();
2018  XCP_CHECK_MEMORY_ACCESS(Xcp_State.mta, len, XCP_MEM_ACCESS_WRITE,
2019  (bool)XCP_TRUE);
2020  src.address = (Xcp_PointerSizeType)pdu->data + 2;
2021  src.ext = UINT8(0);
2022  // Xcp_CopyMemory(Xcp_State.mta, src, (uint32_t)len);
2023 
2024  XCP_INCREMENT_MTA(len);
2025 
2026  Xcp_PositiveResponse();
2027 }
2028 
2029 XCP_STATIC void Xcp_ProgramReset_Res(Xcp_PduType const *const pdu) {
2030  DBG_TRACE1("PROGRAM_RESET\n\r");
2031  XCP_ASSERT_PGM_ACTIVE();
2032 
2033  XcpPgm_SetProcessorState(XCP_PGM_IDLE);
2034  Xcp_PositiveResponse();
2035 }
2036 
2037 #if XCP_ENABLE_GET_PGM_PROCESSOR_INFO == XCP_ON
2038 
2039 XCP_STATIC void Xcp_GetPgmProcessorInfo_Res(Xcp_PduType const *const pdu) {
2040  DBG_TRACE1("GET_PGM_PROCESSOR_INFO\n\r");
2041  /* XCP_ASSERT_UNLOCKED(XCP_RESOURCE_PGM); */
2042 
2043  Xcp_Send8(UINT8(3), UINT8(XCP_PACKET_IDENTIFIER_RES),
2044  XCP_PGM_PROPERIES, /* PGM_PROPERTIES */
2045  XCP_MAX_SECTOR_PGM, /* MAX_SECTOR */
2046  UINT8(0), UINT8(0), UINT8(0), UINT8(0), UINT8(0));
2047 }
2048 
2049 #endif /* XCP_ENABLE_GET_PGM_PROCESSOR_INFO */
2050 
2051 #if XCP_ENABLE_GET_SECTOR_INFO == XCP_ON
2052 
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));
2056 
2057  DBG_TRACE3("GET_SECTOR_INFO [sectorNumber: %d mode :%d]\n\r", sectorNumber,
2058  mode);
2059 
2060  /* XCP_ASSERT_UNLOCKED(XCP_RESOURCE_PGM); */
2061 
2062  if (sectorNumber >= XCP_MAX_SECTOR_PGM) {
2063  Xcp_SendResult(ERR_SEGMENT_NOT_VALID);
2064  return;
2065  }
2066 
2067  if (mode == UINT8(0)) {
2068  /* Start-Address */
2069  } else if (mode == UINT8(1)) {
2070  /* Length */
2071  } else {
2072  Xcp_SendResult(ERR_MODE_NOT_VALID);
2073  return;
2074  }
2075 
2076  Xcp_Send8(UINT8(8), UINT8(XCP_PACKET_IDENTIFIER_RES),
2077  UINT8(sectorNumber * 2), /* Clear Sequence Number */
2078  UINT8((sectorNumber * 2) + 1), /* Program Sequence Number */
2079  UINT8(0), /* Programming method */
2080  UINT8(0), /* SECTOR_INFO - DWORD*/
2081  UINT8(0), UINT8(0), UINT8(0));
2082 }
2083 
2084 #endif /* XCP_ENABLE_GET_SECTOR_INFO */
2085 
2086 #if XCP_ENABLE_PROGRAM_PREPARE == XCP_ON
2087 
2088 XCP_STATIC void Xcp_ProgramPrepare_Res(Xcp_PduType const *const pdu) {
2089  uint16_t codeSize = Xcp_GetWord(pdu, UINT8(2));
2090 
2091  DBG_TRACE2("PROGRAM_PREPARE [codeSize: %d]\n\r", codeSize);
2092  XCP_ASSERT_PGM_ACTIVE();
2093 
2094  Xcp_PositiveResponse();
2095 }
2096 
2097 #endif /* XCP_ENABLE_PROGRAM_PREPARE */
2098 
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));
2105 
2106  DBG_TRACE5("PROGRAM_FORMAT [compression: %d encryption: %d programming: %d "
2107  "access: %d]\n\r",
2108  compressionMethod, encryptionMethod, programmingMethod,
2109  accessMethod);
2110  XCP_ASSERT_PGM_ACTIVE();
2111 
2112  Xcp_PositiveResponse();
2113 }
2114 #endif /* XCP_ENABLE_PROGRAM_FORMAT */
2115 
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();
2120 
2121  Xcp_PositiveResponse();
2122 }
2123 #endif /* XCP_ENABLE_PROGRAM_NEXT */
2124 
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();
2129 
2130  Xcp_PositiveResponse();
2131 }
2132 #endif /* XCP_ENABLE_PROGRAM_MAX */
2133 
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();
2138 
2139  Xcp_PositiveResponse();
2140 }
2141 #endif /* XCP_ENABLE_PROGRAM_VERIFY */
2142 
2143 #endif /* XCP_ENABLE_PGM_COMMANDS */
2144 
2145 /*
2146 ** Helpers.
2147 */
2148 XCP_STATIC void Xcp_SendResult(Xcp_ReturnType result) {
2149  if (result == ERR_SUCCESS) {
2150  Xcp_PositiveResponse();
2151  } else {
2152  Xcp_ErrorResponse(UINT8(result));
2153  }
2154 }
2155 
2156 #if 0
2157 void Xcp_WriteMemory(void * dest, void * src, uint16_t count)
2158 {
2159  XcpUtl_MemCopy(dest, src, UINT32(count));
2160 }
2161 #endif
2162 
2163 #if XCP_REPLACE_STD_COPY_MEMORY == XCP_OFF
2164 
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;
2170 
2171  tmpD.address = dst.address;
2172  tmpS.address = src.address;
2173 
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) {
2178  } else {
2179  }
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) {
2184  } else {
2185  }
2186  XcpUtl_MemCopy((void *)tmpD.address, (void *)tmpS.address, len);
2187 #else
2188 
2189  /* Without address-mapper we don't know how to handle address extensions. */
2190  XcpUtl_MemCopy((void *)dst.address, (void *)src.address, len);
2191 #endif /* XCP_ENABLE_ADDRESS_MAPPER */
2192 }
2193 
2194 #endif /* XCP_REPLACE_STD_COPY_MEMORY */
2195 
2196 INLINE uint8_t Xcp_GetByte(Xcp_PduType const *const pdu, uint8_t offs) {
2197  return (*(pdu->data + offs));
2198 }
2199 
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));
2207 #endif
2208 }
2209 
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);
2213 
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);
2220 #endif
2221  return (uint32_t)(h * 0x10000) + l;
2222 }
2223 
2224 INLINE void Xcp_SetByte(Xcp_PduType const *const pdu, uint8_t offs,
2225  uint8_t value) {
2226  (*(pdu->data + offs)) = value;
2227 }
2228 
2229 INLINE void Xcp_SetWord(Xcp_PduType const *const pdu, uint8_t offs,
2230  uint16_t value) {
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);
2237 #endif
2238 }
2239 
2240 INLINE void Xcp_SetDWord(Xcp_PduType const *const pdu, uint8_t offs,
2241  uint32_t value) {
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));
2248 #endif
2249 }
2250 
2251 XCP_STATIC uint8_t Xcp_SetResetBit8(uint8_t result, uint8_t value,
2252  uint8_t flag) {
2253  if ((value & flag) == flag) {
2254  result |= flag;
2255  } else {
2256  result &= ~flag;
2257  }
2258  return result;
2259 }
2260 
2261 #if XCP_ENABLE_RESOURCE_PROTECTION == XCP_ON
2262 XCP_STATIC bool Xcp_IsProtected(uint8_t resource) {
2263  return ((Xcp_State.resourceProtection & resource) == resource);
2264 }
2265 #else
2266 
2267 XCP_STATIC bool Xcp_IsProtected(uint8_t resource) { return XCP_FALSE; }
2268 
2269 #endif /* XCP_ENABLE_RESOURCE_PROTECTION */
2270 
2271 void Xcp_SetBusy(bool enable) {
2272  XCP_ENTER_CRITICAL();
2273  Xcp_State.busy = enable;
2274  XCP_LEAVE_CRITICAL();
2275 }
2276 
2277 bool Xcp_IsBusy(void) { return Xcp_State.busy; }
2278 
2279 Xcp_StateType *Xcp_GetState(void) {
2280  Xcp_StateType *tState = XCP_NULL;
2281 
2282  XCP_DAQ_ENTER_CRITICAL();
2283  tState = &Xcp_State;
2284  XCP_DAQ_LEAVE_CRITICAL();
2285 
2286  return tState;
2287 }
2288 
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));
2292 }
2293 
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));
2297 }
2298 
2299 XCP_STATIC void Xcp_BusyResponse(void) {
2300 #if XCP_ENABLE_STATISTICS == XCP_ON
2301  Xcp_State.statistics.crosBusy++;
2302 #endif /* XCP_ENABLE_STATISTICS */
2303  Xcp_ErrorResponse(ERR_CMD_BUSY);
2304 }
2305 
2306 #if (XCP_ENABLE_SERVICE_REQUEST_API == XCP_ON) || (XCP_ENABLE_EVENT_PACKET_API)
2307 
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);
2314 
2315  dataLength = XCP_MIN(XCP_MAX_CTO - 2, dataLength); /* Silently truncate. */
2316 
2317 #if XCP_ON_CAN_MAX_DLC_REQUIRED == XCP_ON
2318  frameLength = XCP_MAX_CTO;
2319 #else
2320  frameLength = dataLength + 2;
2321 #endif /* XCP_ON_CAN_MAX_DLC_REQUIRED */
2322  Xcp_SetCtoOutLen(UINT16(frameLength));
2323  dataOut[0] = packetType;
2324  dataOut[1] = code;
2325  if (dataLength) {
2326  for (idx = UINT8(0); idx < dataLength; ++idx) {
2327  dataOut[2 + idx] = data[idx];
2328  }
2329  }
2330  Xcp_SendCto();
2331 }
2332 
2333 #endif
2334 
2335 #if XCP_ENABLE_EVENT_PACKET_API == XCP_ON
2336 
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,
2340  eventInfoLength);
2341 }
2342 
2343 #endif /* XCP_ENABLE_EVENT_PACKET_API */
2344 
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);
2351 }
2352 #endif /* XCP_ENABLE_SERVICE_REQUEST_API */
2353 
2354 #if 0
2355 XCP_STATIC Xcp_MemoryMappingResultType Xcp_MapMemory(Xcp_MtaType const * src, Xcp_MtaType * dst)
2356 {
2357  Xcp_MemoryMappingResultType mappingResult;
2358 
2359 /* FlsEmu_MemoryMapper(tmpAddr); */
2360 
2361  Xcp_MtaType dest;
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;
2365  }
2366  printf("MAPPED: addr: %x ext: %d\n", mta->address, mta->ext);
2367 }
2368 #endif
2369 
2370 XCP_STATIC void Xcp_Download_Copy(uint32_t address, uint8_t ext, uint32_t len) {
2371  Xcp_MtaType src = {0};
2372 
2373  src.address = address;
2374  src.ext = ext;
2375  Xcp_CopyMemory(Xcp_State.mta, src, len);
2376  XCP_INCREMENT_MTA(len);
2377 }
2378 
2379 #if XCP_ENABLE_PGM_COMMANDS == XCP_ON
2380 
2381 void XcpPgm_SetProcessorState(XcpPgm_ProcessorStateType state) {
2382  Xcp_StateType *tmpState = {0};
2383 
2384  tmpState = Xcp_GetState();
2385  XCP_PGM_ENTER_CRITICAL();
2386  tmpState->pgmProcessor.state = state;
2387  XCP_PGM_LEAVE_CRITICAL();
2388 }
2389 
2390 #endif /* ENABLE_PGM_COMMANDS */
2391 
2392 #if XCP_ENABLE_DAQ_COMMANDS == XCP_ON
2393 
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;
2397 
2398  DBG_TRACE5(
2399  "\tentry: [address: 0x%08x ext: 0x%02x size: %u bitOffset: %u]\n\r",
2400  address, adddrExt, elemSize, bitOffset);
2401 
2402  entry =
2403  XcpDaq_GetOdtEntry(Xcp_State.daqPointer.daqList, Xcp_State.daqPointer.odt,
2404  Xcp_State.daqPointer.odtEntry);
2405 
2406 #if XCP_DAQ_BIT_OFFSET_SUPPORTED == XCP_ON
2407  entry->bitOffset = bitOffset;
2408 #endif /* XCP_DAQ_ENABLE_BIT_OFFSET */
2409  entry->length = elemSize;
2410  entry->mta.address = address;
2411 #if XCP_DAQ_ADDR_EXT_SUPPORTED == XCP_ON
2412  entry->mta.ext = adddrExt;
2413 #endif /* XCP_DAQ_ENABLE_ADDR_EXT */
2414 
2415  /* Advance ODT entry pointer within one and the same ODT.
2416  * After writing to the last ODT entry of an ODT, the value
2417  * of the DAQ pointer is undefined!
2418  */
2419  Xcp_State.daqPointer.odtEntry += (XcpDaq_ODTEntryIntegerType)1;
2420 }
2421 #endif /* XCP_ENABLE_DAQ_COMMANDS */