1 /**************************************************************************/
2 /* */
3 /* Copyright (c) Microsoft Corporation. All rights reserved. */
4 /* */
5 /* This software is licensed under the Microsoft Software License */
6 /* Terms for Microsoft Azure RTOS. Full text of the license can be */
7 /* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
8 /* and in the root directory of this software. */
9 /* */
10 /**************************************************************************/
11
12
13 /**************************************************************************/
14 /**************************************************************************/
15 /** */
16 /** ThreadX Component */
17 /** */
18 /** ThreadX MISRA Compliance */
19 /** */
20 /**************************************************************************/
21 /**************************************************************************/
22
23
24 /**************************************************************************/
25 /**************************************************************************/
26 /** */
27 /** _tx_version_id */
28 /** */
29 /**************************************************************************/
30 /**************************************************************************/
31
32 #ifdef TX_MISRA_ENABLE
33 #define TX_THREAD_INIT
34 //CHAR _tx_version_id[100] = "Copyright (c) Microsoft Corporation. All rights reserved. * ThreadX 6.1 MISRA C Compliant *";
35
36 #include "tx_api.h"
37 #include "tx_thread.h"
38 #include "tx_trace.h"
39
40
41 /**************************************************************************/
42 /**************************************************************************/
43 /** */
44 /** VOID _tx_misra_memset(VOID *ptr, UINT value, UINT size); */
45 /** */
46 /**************************************************************************/
47 /**************************************************************************/
_tx_misra_memset(VOID * ptr,UINT value,UINT size)48 VOID _tx_misra_memset(VOID *ptr, UINT value, UINT size)
49 {
50 memset(ptr, value, size);
51 }
52
53
54 /**************************************************************************/
55 /**************************************************************************/
56 /** */
57 /** UCHAR *_tx_misra_uchar_pointer_add(UCHAR *ptr, ULONG amount); */
58 /** */
59 /**************************************************************************/
60 /**************************************************************************/
_tx_misra_uchar_pointer_add(UCHAR * ptr,ULONG amount)61 UCHAR *_tx_misra_uchar_pointer_add(UCHAR *ptr, ULONG amount)
62 {
63 ptr = ptr + amount;
64 return(ptr);
65 }
66
67
68 /**************************************************************************/
69 /**************************************************************************/
70 /** */
71 /** UCHAR *_tx_misra_uchar_pointer_sub(UCHAR *ptr, ULONG amount); */
72 /** */
73 /**************************************************************************/
74 /**************************************************************************/
_tx_misra_uchar_pointer_sub(UCHAR * ptr,ULONG amount)75 UCHAR *_tx_misra_uchar_pointer_sub(UCHAR *ptr, ULONG amount)
76 {
77 ptr = ptr - amount;
78 return(ptr);
79 }
80
81
82 /**************************************************************************/
83 /**************************************************************************/
84 /** */
85 /** ULONG _tx_misra_uchar_pointer_dif(UCHAR *ptr1, UCHAR *ptr2); */
86 /** */
87 /**************************************************************************/
88 /**************************************************************************/
_tx_misra_uchar_pointer_dif(UCHAR * ptr1,UCHAR * ptr2)89 ULONG _tx_misra_uchar_pointer_dif(UCHAR *ptr1, UCHAR *ptr2)
90 {
91
92 ULONG value;
93
94 value = ptr1 - ptr2;
95 return(value);
96 }
97
98
99 /**************************************************************************/
100 /**************************************************************************/
101 /** */
102 /** ULONG _tx_misra_pointer_to_ulong_convert(VOID *ptr); */
103 /** */
104 /**************************************************************************/
105 /**************************************************************************/
_tx_misra_pointer_to_ulong_convert(VOID * ptr)106 ULONG _tx_misra_pointer_to_ulong_convert(VOID *ptr)
107 {
108 return((ULONG) ptr);
109 }
110
111
112 /**************************************************************************/
113 /**************************************************************************/
114 /** */
115 /** ULONG *_tx_misra_ulong_pointer_add(ULONG *ptr, ULONG amount); */
116 /** */
117 /**************************************************************************/
118 /**************************************************************************/
_tx_misra_ulong_pointer_add(ULONG * ptr,ULONG amount)119 ULONG *_tx_misra_ulong_pointer_add(ULONG *ptr, ULONG amount)
120 {
121 ptr = ptr + amount;
122 return(ptr);
123 }
124
125
126 /**************************************************************************/
127 /**************************************************************************/
128 /** */
129 /** ULONG *_tx_misra_ulong_pointer_sub(ULONG *ptr, ULONG amount); */
130 /** */
131 /**************************************************************************/
132 /**************************************************************************/
_tx_misra_ulong_pointer_sub(ULONG * ptr,ULONG amount)133 ULONG *_tx_misra_ulong_pointer_sub(ULONG *ptr, ULONG amount)
134 {
135
136 ptr = ptr - amount;
137 return(ptr);
138 }
139
140
141 /**************************************************************************/
142 /**************************************************************************/
143 /** */
144 /** ULONG _tx_misra_ulong_pointer_dif(ULONG *ptr1, ULONG *ptr2); */
145 /** */
146 /**************************************************************************/
147 /**************************************************************************/
_tx_misra_ulong_pointer_dif(ULONG * ptr1,ULONG * ptr2)148 ULONG _tx_misra_ulong_pointer_dif(ULONG *ptr1, ULONG *ptr2)
149 {
150 ULONG value;
151
152 value = ptr1 - ptr2;
153 return(value);
154 }
155
156
157 /**************************************************************************/
158 /**************************************************************************/
159 /** */
160 /** VOID *_tx_misra_ulong_to_pointer_convert(ULONG input); */
161 /** */
162 /**************************************************************************/
163 /**************************************************************************/
_tx_misra_ulong_to_pointer_convert(ULONG input)164 VOID *_tx_misra_ulong_to_pointer_convert(ULONG input)
165 {
166
167 return((VOID *) input);
168 }
169
170
171 /**************************************************************************/
172 /**************************************************************************/
173 /** */
174 /** VOID _tx_misra_message_copy(ULONG **source, ULONG **destination, */
175 /** UINT size); */
176 /** */
177 /**************************************************************************/
178 /**************************************************************************/
_tx_misra_message_copy(ULONG ** source,ULONG ** destination,UINT size)179 VOID _tx_misra_message_copy(ULONG **source, ULONG **destination, UINT size)
180 {
181
182 ULONG *s, *d;
183 UINT z;
184
185 s = *source;
186 d = *destination;
187 z = size;
188
189 *(d) = *(s);
190 (d)++;
191 (s)++;
192 if ((z) > ((UINT) 1))
193 {
194 (z)--;
195 while ((z))
196 {
197 *(d) = *(s);
198 (d)++;
199 (s)++;
200 (z)--;
201 }
202 }
203
204 *source = s;
205 *destination = d;
206 }
207
208
209 /**************************************************************************/
210 /**************************************************************************/
211 /** */
212 /** ULONG _tx_misra_timer_pointer_dif(TX_TIMER_INTERNAL **ptr1, */
213 /** TX_TIMER_INTERNAL **ptr2); */
214 /** */
215 /**************************************************************************/
216 /**************************************************************************/
_tx_misra_timer_pointer_dif(TX_TIMER_INTERNAL ** ptr1,TX_TIMER_INTERNAL ** ptr2)217 ULONG _tx_misra_timer_pointer_dif(TX_TIMER_INTERNAL **ptr1, TX_TIMER_INTERNAL **ptr2)
218 {
219
220 ULONG value;
221
222 value = ptr1 - ptr2;
223 return(value);
224 }
225
226
227 /**************************************************************************/
228 /**************************************************************************/
229 /** */
230 /** TX_TIMER_INTERNAL **_tx_misra_timer_pointer_add(TX_TIMER_INTERNAL */
231 /** **ptr1, ULONG size); */
232 /** */
233 /**************************************************************************/
234 /**************************************************************************/
_tx_misra_timer_pointer_add(TX_TIMER_INTERNAL ** ptr1,ULONG amount)235 TX_TIMER_INTERNAL **_tx_misra_timer_pointer_add(TX_TIMER_INTERNAL **ptr1, ULONG amount)
236 {
237 ptr1 = ptr1 + amount;
238 return(ptr1);
239 }
240
241
242 /**************************************************************************/
243 /**************************************************************************/
244 /** */
245 /** VOID _tx_misra_user_timer_pointer_get(TX_TIMER_INTERNAL */
246 /** *internal_timer, TX_TIMER **user_timer); */
247 /** */
248 /**************************************************************************/
249 /**************************************************************************/
_tx_misra_user_timer_pointer_get(TX_TIMER_INTERNAL * internal_timer,TX_TIMER ** user_timer)250 VOID _tx_misra_user_timer_pointer_get(TX_TIMER_INTERNAL *internal_timer, TX_TIMER **user_timer)
251 {
252
253 UCHAR *working_ptr;
254 TX_TIMER *temp_timer;
255
256
257 working_ptr = (UCHAR *) internal_timer;
258
259 temp_timer = (TX_TIMER *) working_ptr;
260 working_ptr = working_ptr - (((UCHAR *) &temp_timer -> tx_timer_internal) - ((UCHAR *) &temp_timer -> tx_timer_id));
261 *user_timer = (TX_TIMER *) working_ptr;
262 }
263
264
265 /**************************************************************************/
266 /**************************************************************************/
267 /** */
268 /** VOID _tx_misra_thread_stack_check(TX_THREAD *thread_ptr, */
269 /** VOID **highest_stack); */
270 /** */
271 /**************************************************************************/
272 /**************************************************************************/
_tx_misra_thread_stack_check(TX_THREAD * thread_ptr,VOID ** highest_stack)273 VOID _tx_misra_thread_stack_check(TX_THREAD *thread_ptr, VOID **highest_stack)
274 {
275
276 TX_INTERRUPT_SAVE_AREA
277
278 TX_DISABLE
279 if (((thread_ptr)) && ((thread_ptr) -> tx_thread_id == TX_THREAD_ID))
280 {
281 if (((ULONG *) (thread_ptr) -> tx_thread_stack_ptr) < ((ULONG *) *highest_stack))
282 {
283 *highest_stack = (thread_ptr) -> tx_thread_stack_ptr;
284 }
285 if ((*((ULONG *) (thread_ptr) -> tx_thread_stack_start) != TX_STACK_FILL) ||
286 (*((ULONG *) (((UCHAR *) (thread_ptr) -> tx_thread_stack_end) + 1)) != TX_STACK_FILL) ||
287 (((ULONG *) *highest_stack) < ((ULONG *) (thread_ptr) -> tx_thread_stack_start)))
288 {
289 TX_RESTORE
290 _tx_thread_stack_error_handler((thread_ptr));
291 TX_DISABLE
292 }
293 if (*(((ULONG *) *highest_stack) - 1) != TX_STACK_FILL)
294 {
295 TX_RESTORE
296 _tx_thread_stack_analyze((thread_ptr));
297 TX_DISABLE
298 }
299 }
300 TX_RESTORE
301 }
302
303
304 #ifdef TX_ENABLE_EVENT_TRACE
305
306 /**************************************************************************/
307 /**************************************************************************/
308 /** */
309 /** VOID _tx_misra_trace_event_insert(ULONG event_id, */
310 /** VOID *info_field_1, ULONG info_field_2, ULONG info_field_3, */
311 /** ULONG info_field_4, ULONG filter, ULONG time_stamp); */
312 /** */
313 /**************************************************************************/
314 /**************************************************************************/
_tx_misra_trace_event_insert(ULONG event_id,VOID * info_field_1,ULONG info_field_2,ULONG info_field_3,ULONG info_field_4,ULONG filter,ULONG time_stamp)315 VOID _tx_misra_trace_event_insert(ULONG event_id, VOID *info_field_1, ULONG info_field_2, ULONG info_field_3, ULONG info_field_4, ULONG filter, ULONG time_stamp)
316 {
317
318 TX_TRACE_BUFFER_ENTRY *trace_event_ptr;
319 ULONG trace_system_state;
320 ULONG trace_priority;
321 TX_THREAD *trace_thread_ptr;
322
323
324 trace_event_ptr = _tx_trace_buffer_current_ptr;
325 if ((trace_event_ptr) && (_tx_trace_event_enable_bits & ((ULONG) (filter))))
326 {
327 TX_TRACE_PORT_EXTENSION
328 trace_system_state = (ULONG) _tx_thread_system_state;
329 trace_thread_ptr = _tx_thread_current_ptr;
330
331 if (trace_system_state == 0)
332 {
333 trace_priority = trace_thread_ptr -> tx_thread_priority;
334 trace_priority = trace_priority | 0x80000000UL | (trace_thread_ptr -> tx_thread_preempt_threshold << 16);
335 }
336 else if (trace_system_state < 0xF0F0F0F0UL)
337 {
338 trace_priority = (ULONG) trace_thread_ptr;
339 trace_thread_ptr = (TX_THREAD *) 0xFFFFFFFFUL;
340 }
341 else
342 {
343 trace_thread_ptr = (TX_THREAD *) 0xF0F0F0F0UL;
344 trace_priority = 0;
345 }
346 trace_event_ptr -> tx_trace_buffer_entry_thread_pointer = (ULONG) trace_thread_ptr;
347 trace_event_ptr -> tx_trace_buffer_entry_thread_priority = (ULONG) trace_priority;
348 trace_event_ptr -> tx_trace_buffer_entry_event_id = (ULONG) (event_id);
349 trace_event_ptr -> tx_trace_buffer_entry_time_stamp = (ULONG) (time_stamp);
350 #ifdef TX_MISRA_ENABLE
351 trace_event_ptr -> tx_trace_buffer_entry_info_1 = (ULONG) (info_field_1);
352 trace_event_ptr -> tx_trace_buffer_entry_info_2 = (ULONG) (info_field_2);
353 trace_event_ptr -> tx_trace_buffer_entry_info_3 = (ULONG) (info_field_3);
354 trace_event_ptr -> tx_trace_buffer_entry_info_4 = (ULONG) (info_field_4);
355 #else
356 trace_event_ptr -> tx_trace_buffer_entry_information_field_1 = (ULONG) (info_field_1);
357 trace_event_ptr -> tx_trace_buffer_entry_information_field_2 = (ULONG) (info_field_2);
358 trace_event_ptr -> tx_trace_buffer_entry_information_field_3 = (ULONG) (info_field_3);
359 trace_event_ptr -> tx_trace_buffer_entry_information_field_4 = (ULONG) (info_field_4);
360 #endif
361 trace_event_ptr++;
362 if (trace_event_ptr >= _tx_trace_buffer_end_ptr)
363 {
364 trace_event_ptr = _tx_trace_buffer_start_ptr;
365 _tx_trace_buffer_current_ptr = trace_event_ptr;
366 _tx_trace_header_ptr -> tx_trace_header_buffer_current_pointer = (ULONG) trace_event_ptr;
367 if (_tx_trace_full_notify_function)
368 (_tx_trace_full_notify_function)((VOID *) _tx_trace_header_ptr);
369 }
370 else
371 {
372 _tx_trace_buffer_current_ptr = trace_event_ptr;
373 _tx_trace_header_ptr -> tx_trace_header_buffer_current_pointer = (ULONG) trace_event_ptr;
374 }
375 }
376 }
377
378 /**************************************************************************/
379 /**************************************************************************/
380 /** */
381 /** ULONG _tx_misra_time_stamp_get(VOID); */
382 /** */
383 /**************************************************************************/
384 /**************************************************************************/
_tx_misra_time_stamp_get(VOID)385 ULONG _tx_misra_time_stamp_get(VOID)
386 {
387
388 /* Return time stamp. */
389 return(0);
390 }
391
392 #endif
393
394
395 /**************************************************************************/
396 /**************************************************************************/
397 /** */
398 /** UINT _tx_misra_always_true(void); */
399 /** */
400 /**************************************************************************/
401 /**************************************************************************/
_tx_misra_always_true(void)402 UINT _tx_misra_always_true(void)
403 {
404 return(TX_TRUE);
405 }
406
407
408 /******************************************************************************************/
409 /******************************************************************************************/
410 /** */
411 /** UCHAR **_tx_misra_indirect_void_to_uchar_pointer_convert(VOID **return_ptr); */
412 /** */
413 /******************************************************************************************/
414 /******************************************************************************************/
_tx_misra_indirect_void_to_uchar_pointer_convert(VOID ** return_ptr)415 UCHAR **_tx_misra_indirect_void_to_uchar_pointer_convert(VOID **return_ptr)
416 {
417
418 /* Return an indirect UCHAR pointer. */
419 return((UCHAR **) ((VOID *) return_ptr));
420 }
421
422
423 /***************************************************************************************/
424 /***************************************************************************************/
425 /** */
426 /** UCHAR **_tx_misra_uchar_to_indirect_uchar_pointer_convert(UCHAR *pointer); */
427 /** */
428 /***************************************************************************************/
429 /***************************************************************************************/
_tx_misra_uchar_to_indirect_uchar_pointer_convert(UCHAR * pointer)430 UCHAR **_tx_misra_uchar_to_indirect_uchar_pointer_convert(UCHAR *pointer)
431 {
432
433 /* Return an indirect UCHAR pointer. */
434 return((UCHAR **) ((VOID *) pointer));
435 }
436
437
438 /***********************************************************************************/
439 /***********************************************************************************/
440 /** */
441 /** UCHAR *_tx_misra_block_pool_to_uchar_pointer_convert(TX_BLOCK_POOL *pool); */
442 /** */
443 /***********************************************************************************/
444 /***********************************************************************************/
_tx_misra_block_pool_to_uchar_pointer_convert(TX_BLOCK_POOL * pool)445 UCHAR *_tx_misra_block_pool_to_uchar_pointer_convert(TX_BLOCK_POOL *pool)
446 {
447
448 /* Return a UCHAR pointer. */
449 return((UCHAR *) ((VOID *) pool));
450 }
451
452
453 /******************************************************************************************/
454 /******************************************************************************************/
455 /** */
456 /** TX_BLOCK_POOL *_tx_misra_void_to_block_pool_pointer_convert(VOID *pointer); */
457 /** */
458 /******************************************************************************************/
459 /******************************************************************************************/
_tx_misra_void_to_block_pool_pointer_convert(VOID * pointer)460 TX_BLOCK_POOL *_tx_misra_void_to_block_pool_pointer_convert(VOID *pointer)
461 {
462
463 /* Return a block pool pointer. */
464 return((TX_BLOCK_POOL *) ((VOID *) pointer));
465 }
466
467
468 /*****************************************************************************/
469 /*****************************************************************************/
470 /** */
471 /** UCHAR *_tx_misra_void_to_uchar_pointer_convert(VOID *pointer); */
472 /** */
473 /*****************************************************************************/
474 /*****************************************************************************/
_tx_misra_void_to_uchar_pointer_convert(VOID * pointer)475 UCHAR *_tx_misra_void_to_uchar_pointer_convert(VOID *pointer)
476 {
477
478 /* Return a UCHAR pointer. */
479 return((UCHAR *) ((VOID *) pointer));
480 }
481
482
483 /************************************************************************************/
484 /************************************************************************************/
485 /** */
486 /** TX_BLOCK_POOL *_tx_misra_uchar_to_block_pool_pointer_convert(UCHAR *pointer); */
487 /** */
488 /************************************************************************************/
489 /************************************************************************************/
_tx_misra_uchar_to_block_pool_pointer_convert(UCHAR * pointer)490 TX_BLOCK_POOL *_tx_misra_uchar_to_block_pool_pointer_convert(UCHAR *pointer)
491 {
492
493 /* Return a UCHAR pointer. */
494 return((TX_BLOCK_POOL *) ((VOID *) pointer));
495 }
496
497
498 /**************************************************************************************/
499 /**************************************************************************************/
500 /** */
501 /** UCHAR **_tx_misra_void_to_indirect_uchar_pointer_convert(VOID *pointer); */
502 /** */
503 /**************************************************************************************/
504 /**************************************************************************************/
_tx_misra_void_to_indirect_uchar_pointer_convert(VOID * pointer)505 UCHAR **_tx_misra_void_to_indirect_uchar_pointer_convert(VOID *pointer)
506 {
507
508 /* Return a UCHAR pointer. */
509 return((UCHAR **) ((VOID *) pointer));
510 }
511
512
513 /*****************************************************************************************/
514 /*****************************************************************************************/
515 /** */
516 /** TX_BYTE_POOL *_tx_misra_void_to_byte_pool_pointer_convert(VOID *pointer); */
517 /** */
518 /*****************************************************************************************/
519 /*****************************************************************************************/
_tx_misra_void_to_byte_pool_pointer_convert(VOID * pointer)520 TX_BYTE_POOL *_tx_misra_void_to_byte_pool_pointer_convert(VOID *pointer)
521 {
522
523 /* Return a byte pool pointer. */
524 return((TX_BYTE_POOL *) ((VOID *) pointer));
525 }
526
527
528 /***************************************************************************************/
529 /***************************************************************************************/
530 /** */
531 /** UCHAR *_tx_misra_byte_pool_to_uchar_pointer_convert(TX_BYTE_POOL *pool); */
532 /** */
533 /***************************************************************************************/
534 /***************************************************************************************/
_tx_misra_byte_pool_to_uchar_pointer_convert(TX_BYTE_POOL * pool)535 UCHAR *_tx_misra_byte_pool_to_uchar_pointer_convert(TX_BYTE_POOL *pool)
536 {
537
538 /* Return a UCHAR pointer. */
539 return((UCHAR *) ((VOID *) pool));
540 }
541
542
543 /*****************************************************************************************/
544 /*****************************************************************************************/
545 /** */
546 /** ALIGN_TYPE *_tx_misra_uchar_to_align_type_pointer_convert(UCHAR *pointer); */
547 /** */
548 /*****************************************************************************************/
549 /*****************************************************************************************/
_tx_misra_uchar_to_align_type_pointer_convert(UCHAR * pointer)550 ALIGN_TYPE *_tx_misra_uchar_to_align_type_pointer_convert(UCHAR *pointer)
551 {
552
553 /* Return an align time pointer. */
554 return((ALIGN_TYPE *) ((VOID *) pointer));
555 }
556
557
558 /****************************************************************************************************/
559 /****************************************************************************************************/
560 /** */
561 /** TX_BYTE_POOL **_tx_misra_uchar_to_indirect_byte_pool_pointer_convert(UCHAR *pointer); */
562 /** */
563 /****************************************************************************************************/
564 /****************************************************************************************************/
_tx_misra_uchar_to_indirect_byte_pool_pointer_convert(UCHAR * pointer)565 TX_BYTE_POOL **_tx_misra_uchar_to_indirect_byte_pool_pointer_convert(UCHAR *pointer)
566 {
567
568 /* Return a byte pool pointer. */
569 return((TX_BYTE_POOL **) ((VOID *) pointer));
570 }
571
572
573 /**************************************************************************************************/
574 /**************************************************************************************************/
575 /** */
576 /** TX_EVENT_FLAGS_GROUP *_tx_misra_void_to_event_flags_pointer_convert(VOID *pointer); */
577 /** */
578 /**************************************************************************************************/
579 /**************************************************************************************************/
_tx_misra_void_to_event_flags_pointer_convert(VOID * pointer)580 TX_EVENT_FLAGS_GROUP *_tx_misra_void_to_event_flags_pointer_convert(VOID *pointer)
581 {
582
583 /* Return event flags pointer. */
584 return((TX_EVENT_FLAGS_GROUP *) ((VOID *) pointer));
585 }
586
587
588 /*****************************************************************************/
589 /*****************************************************************************/
590 /** */
591 /** ULONG *_tx_misra_void_to_ulong_pointer_convert(VOID *pointer); */
592 /** */
593 /*****************************************************************************/
594 /*****************************************************************************/
_tx_misra_void_to_ulong_pointer_convert(VOID * pointer)595 ULONG *_tx_misra_void_to_ulong_pointer_convert(VOID *pointer)
596 {
597
598 /* Return a ULONG pointer. */
599 return((ULONG *) ((VOID *) pointer));
600 }
601
602
603 /********************************************************************************/
604 /********************************************************************************/
605 /** */
606 /** TX_MUTEX *_tx_misra_void_to_mutex_pointer_convert(VOID *pointer); */
607 /** */
608 /********************************************************************************/
609 /********************************************************************************/
_tx_misra_void_to_mutex_pointer_convert(VOID * pointer)610 TX_MUTEX *_tx_misra_void_to_mutex_pointer_convert(VOID *pointer)
611 {
612
613 /* Return a mutex pointer. */
614 return((TX_MUTEX *) ((VOID *) pointer));
615 }
616
617
618 /**************************************************************************/
619 /**************************************************************************/
620 /** */
621 /** UINT _tx_misra_status_get(UINT status); */
622 /** */
623 /**************************************************************************/
624 /**************************************************************************/
_tx_misra_status_get(UINT status)625 UINT _tx_misra_status_get(UINT status)
626 {
627
628 /* Return a successful status. */
629 return(TX_SUCCESS);
630 }
631
632
633 /********************************************************************************/
634 /********************************************************************************/
635 /** */
636 /** TX_QUEUE *_tx_misra_void_to_queue_pointer_convert(VOID *pointer); */
637 /** */
638 /********************************************************************************/
639 /********************************************************************************/
_tx_misra_void_to_queue_pointer_convert(VOID * pointer)640 TX_QUEUE *_tx_misra_void_to_queue_pointer_convert(VOID *pointer)
641 {
642
643 /* Return queue pointer. */
644 return((TX_QUEUE *) ((VOID *) pointer));
645 }
646
647
648 /****************************************************************************************/
649 /****************************************************************************************/
650 /** */
651 /** TX_SEMAPHORE *_tx_misra_void_to_semaphore_pointer_convert(VOID *pointer); */
652 /** */
653 /****************************************************************************************/
654 /****************************************************************************************/
_tx_misra_void_to_semaphore_pointer_convert(VOID * pointer)655 TX_SEMAPHORE *_tx_misra_void_to_semaphore_pointer_convert(VOID *pointer)
656 {
657
658 /* Return semaphore pointer. */
659 return((TX_SEMAPHORE *) ((VOID *) pointer));
660 }
661
662
663 /**************************************************************************/
664 /**************************************************************************/
665 /** */
666 /** VOID *_tx_misra_uchar_to_void_pointer_convert(UCHAR *pointer); */
667 /** */
668 /**************************************************************************/
669 /**************************************************************************/
_tx_misra_uchar_to_void_pointer_convert(UCHAR * pointer)670 VOID *_tx_misra_uchar_to_void_pointer_convert(UCHAR *pointer)
671 {
672
673 /* Return a VOID pointer. */
674 return((VOID *) ((VOID *) pointer));
675 }
676
677
678 /*********************************************************************************/
679 /*********************************************************************************/
680 /** */
681 /** TX_THREAD *_tx_misra_ulong_to_thread_pointer_convert(ULONG value); */
682 /** */
683 /*********************************************************************************/
684 /*********************************************************************************/
_tx_misra_ulong_to_thread_pointer_convert(ULONG value)685 TX_THREAD *_tx_misra_ulong_to_thread_pointer_convert(ULONG value)
686 {
687
688 /* Return a thread pointer. */
689 return((TX_THREAD *) ((VOID *) value));
690 }
691
692
693 /***************************************************************************************************/
694 /***************************************************************************************************/
695 /** */
696 /** VOID *_tx_misra_timer_indirect_to_void_pointer_convert(TX_TIMER_INTERNAL **pointer); */
697 /** */
698 /***************************************************************************************************/
699 /***************************************************************************************************/
_tx_misra_timer_indirect_to_void_pointer_convert(TX_TIMER_INTERNAL ** pointer)700 VOID *_tx_misra_timer_indirect_to_void_pointer_convert(TX_TIMER_INTERNAL **pointer)
701 {
702
703 /* Return a void pointer. */
704 return((VOID *) ((VOID *) pointer));
705 }
706
707
708 /***************************************************************************************/
709 /***************************************************************************************/
710 /** */
711 /** CHAR *_tx_misra_const_char_to_char_pointer_convert(const char *pointer); */
712 /** */
713 /***************************************************************************************/
714 /***************************************************************************************/
_tx_misra_const_char_to_char_pointer_convert(const char * pointer)715 CHAR *_tx_misra_const_char_to_char_pointer_convert(const char *pointer)
716 {
717
718 /* Return a CHAR pointer. */
719 return((CHAR *) ((VOID *) pointer));
720 }
721
722
723 /**********************************************************************************/
724 /**********************************************************************************/
725 /** */
726 /** TX_THREAD *_tx_misra_void_to_thread_pointer_convert(void *pointer); */
727 /** */
728 /**********************************************************************************/
729 /**********************************************************************************/
_tx_misra_void_to_thread_pointer_convert(void * pointer)730 TX_THREAD *_tx_misra_void_to_thread_pointer_convert(void *pointer)
731 {
732
733 /* Return thread pointer. */
734 return((TX_THREAD *) ((VOID *) pointer));
735 }
736
737
738 #ifdef TX_ENABLE_EVENT_TRACE
739
740 /************************************************************************************************/
741 /************************************************************************************************/
742 /** */
743 /** UCHAR *_tx_misra_object_to_uchar_pointer_convert(TX_TRACE_OBJECT_ENTRY *pointer); */
744 /** */
745 /************************************************************************************************/
746 /************************************************************************************************/
_tx_misra_object_to_uchar_pointer_convert(TX_TRACE_OBJECT_ENTRY * pointer)747 UCHAR *_tx_misra_object_to_uchar_pointer_convert(TX_TRACE_OBJECT_ENTRY *pointer)
748 {
749
750 /* Return a UCHAR pointer. */
751 return((UCHAR *) ((VOID *) pointer));
752 }
753
754
755 /************************************************************************************************/
756 /************************************************************************************************/
757 /** */
758 /** TX_TRACE_OBJECT_ENTRY *_tx_misra_uchar_to_object_pointer_convert(UCHAR *pointer); */
759 /** */
760 /************************************************************************************************/
761 /************************************************************************************************/
_tx_misra_uchar_to_object_pointer_convert(UCHAR * pointer)762 TX_TRACE_OBJECT_ENTRY *_tx_misra_uchar_to_object_pointer_convert(UCHAR *pointer)
763 {
764
765 /* Return an object entry pointer. */
766 return((TX_TRACE_OBJECT_ENTRY *) ((VOID *) pointer));
767 }
768
769
770 /******************************************************************************************/
771 /******************************************************************************************/
772 /** */
773 /** TX_TRACE_HEADER *_tx_misra_uchar_to_header_pointer_convert(UCHAR *pointer); */
774 /** */
775 /******************************************************************************************/
776 /******************************************************************************************/
_tx_misra_uchar_to_header_pointer_convert(UCHAR * pointer)777 TX_TRACE_HEADER *_tx_misra_uchar_to_header_pointer_convert(UCHAR *pointer)
778 {
779
780 /* Return a trace header pointer. */
781 return((TX_TRACE_HEADER *) ((VOID *) pointer));
782 }
783
784
785 /***********************************************************************************************/
786 /***********************************************************************************************/
787 /** */
788 /** TX_TRACE_BUFFER_ENTRY *_tx_misra_uchar_to_entry_pointer_convert(UCHAR *pointer); */
789 /** */
790 /***********************************************************************************************/
791 /***********************************************************************************************/
_tx_misra_uchar_to_entry_pointer_convert(UCHAR * pointer)792 TX_TRACE_BUFFER_ENTRY *_tx_misra_uchar_to_entry_pointer_convert(UCHAR *pointer)
793 {
794
795 /* Return a trace buffer entry pointer. */
796 return((TX_TRACE_BUFFER_ENTRY *) ((VOID *) pointer));
797 }
798
799
800 /***********************************************************************************************/
801 /***********************************************************************************************/
802 /** */
803 /** UCHAR *_tx_misra_entry_to_uchar_pointer_convert(TX_TRACE_BUFFER_ENTRY *pointer); */
804 /** */
805 /***********************************************************************************************/
806 /***********************************************************************************************/
_tx_misra_entry_to_uchar_pointer_convert(TX_TRACE_BUFFER_ENTRY * pointer)807 UCHAR *_tx_misra_entry_to_uchar_pointer_convert(TX_TRACE_BUFFER_ENTRY *pointer)
808 {
809
810 /* Return a UCHAR pointer. */
811 return((UCHAR *) ((VOID *) pointer));
812 }
813
814 #endif
815
816
817 /***********************************************************************************************/
818 /***********************************************************************************************/
819 /** */
820 /** UCHAR *_tx_misra_char_to_uchar_pointer_convert(CHAR *pointer); */
821 /** */
822 /***********************************************************************************************/
823 /***********************************************************************************************/
_tx_misra_char_to_uchar_pointer_convert(CHAR * pointer)824 UCHAR *_tx_misra_char_to_uchar_pointer_convert(CHAR *pointer)
825 {
826
827 /* Return a UCHAR pointer. */
828 return((UCHAR *) ((VOID *) pointer));
829 }
830
831
832 #endif
833
834
