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