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 /** Module Manager */
19 /** */
20 /**************************************************************************/
21 /**************************************************************************/
22
23 #define TX_SOURCE_CODE
24
25 #include "tx_api.h"
26 #include "tx_block_pool.h"
27 #include "tx_byte_pool.h"
28 #include "tx_event_flags.h"
29 #include "tx_queue.h"
30 #include "tx_mutex.h"
31 #include "tx_semaphore.h"
32 #include "tx_thread.h"
33 #include "tx_timer.h"
34 #include "tx_trace.h"
35 #include "txm_module.h"
36 #include "txm_module_manager_util.h"
37 #include "txm_module_manager_dispatch.h"
38
39 /**************************************************************************/
40 /* */
41 /* FUNCTION RELEASE */
42 /* */
43 /* _txm_module_manager_kernel_dispatch PORTABLE C */
44 /* 6.1.10 */
45 /* AUTHOR */
46 /* */
47 /* Scott Larson, Microsoft Corporation */
48 /* */
49 /* DESCRIPTION */
50 /* */
51 /* This function dispatches the module's kernel request based upon the */
52 /* ID and parameters specified in the request. */
53 /* To disallow modules to use specific ThreadX services, define */
54 /* TXM_***_CALL_NOT_USED (see #ifndefs surrounding each case). */
55 /* */
56 /* INPUT */
57 /* */
58 /* kernel_request Module's kernel request */
59 /* param_1 First parameter */
60 /* param_2 Second parameter */
61 /* param_3 Third parameter */
62 /* */
63 /* OUTPUT */
64 /* */
65 /* status Completion status */
66 /* */
67 /* CALLS */
68 /* */
69 /* _txm_module_manager_application_request Application-specific req */
70 /* _txm_module_manager_object_pointer_get Find object pointer */
71 /* _txm_module_manager_thread_create Module thread create */
72 /* [_txm_module_manager_*_dispatch] Optional external */
73 /* component dispatch */
74 /* ThreadX API Calls */
75 /* */
76 /* CALLED BY */
77 /* */
78 /* Application code */
79 /* */
80 /* RELEASE HISTORY */
81 /* */
82 /* DATE NAME DESCRIPTION */
83 /* */
84 /* 09-30-2020 Scott Larson Initial Version 6.1 */
85 /* 12-31-2020 Scott Larson Modified comment(s), added */
86 /* port-specific dispatch, */
87 /* resulting in version 6.1.3 */
88 /* 04-02-2021 Scott Larson Modified comment(s), */
89 /* added optional defines to */
90 /* remove unneeded functions, */
91 /* resulting in version 6.1.6 */
92 /* 01-31-2022 Scott Larson Modified comments and added */
93 /* CALL_NOT_USED option, */
94 /* resulting in version 6.1.10 */
95 /* */
96 /**************************************************************************/
_txm_module_manager_kernel_dispatch(ULONG kernel_request,ALIGN_TYPE param_0,ALIGN_TYPE param_1,ALIGN_TYPE param_2)97 ALIGN_TYPE _txm_module_manager_kernel_dispatch(ULONG kernel_request, ALIGN_TYPE param_0, ALIGN_TYPE param_1, ALIGN_TYPE param_2)
98 {
99
100 ALIGN_TYPE return_value = TX_NOT_AVAILABLE;
101 TXM_MODULE_INSTANCE *module_instance;
102
103
104 /* Get the module instance. */
105 module_instance = _tx_thread_current_ptr -> tx_thread_module_instance_ptr;
106
107 /* Sanity-check for a valid module instance. */
108 if (module_instance == TX_NULL)
109 {
110 /* Just return! */
111 return(TXM_MODULE_INVALID);
112 }
113
114 switch (kernel_request)
115 {
116 #ifndef TXM_BLOCK_ALLOCATE_CALL_NOT_USED
117 case TXM_BLOCK_ALLOCATE_CALL:
118 {
119 return_value = _txm_module_manager_tx_block_allocate_dispatch(module_instance, param_0, param_1, param_2);
120 break;
121 }
122 #endif
123
124 #ifndef TXM_BLOCK_POOL_CREATE_CALL_NOT_USED
125 case TXM_BLOCK_POOL_CREATE_CALL:
126 {
127 return_value = _txm_module_manager_tx_block_pool_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
128 break;
129 }
130 #endif
131
132 #ifndef TXM_BLOCK_POOL_DELETE_CALL_NOT_USED
133 case TXM_BLOCK_POOL_DELETE_CALL:
134 {
135 return_value = _txm_module_manager_tx_block_pool_delete_dispatch(module_instance, param_0);
136 break;
137 }
138 #endif
139
140 #ifndef TXM_BLOCK_POOL_INFO_GET_CALL_NOT_USED
141 case TXM_BLOCK_POOL_INFO_GET_CALL:
142 {
143 return_value = _txm_module_manager_tx_block_pool_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
144 break;
145 }
146 #endif
147
148 #ifndef TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
149 case TXM_BLOCK_POOL_PERFORMANCE_INFO_GET_CALL:
150 {
151 return_value = _txm_module_manager_tx_block_pool_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
152 break;
153 }
154 #endif
155
156 #ifndef TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
157 case TXM_BLOCK_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL:
158 {
159 return_value = _txm_module_manager_tx_block_pool_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
160 break;
161 }
162 #endif
163
164 #ifndef TXM_BLOCK_POOL_PRIORITIZE_CALL_NOT_USED
165 case TXM_BLOCK_POOL_PRIORITIZE_CALL:
166 {
167 return_value = _txm_module_manager_tx_block_pool_prioritize_dispatch(module_instance, param_0);
168 break;
169 }
170 #endif
171
172 #ifndef TXM_BLOCK_RELEASE_CALL_NOT_USED
173 case TXM_BLOCK_RELEASE_CALL:
174 {
175 return_value = _txm_module_manager_tx_block_release_dispatch(module_instance, param_0);
176 break;
177 }
178 #endif
179
180 #ifndef TXM_BYTE_ALLOCATE_CALL_NOT_USED
181 case TXM_BYTE_ALLOCATE_CALL:
182 {
183 return_value = _txm_module_manager_tx_byte_allocate_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
184 break;
185 }
186 #endif
187
188 #ifndef TXM_BYTE_POOL_CREATE_CALL_NOT_USED
189 case TXM_BYTE_POOL_CREATE_CALL:
190 {
191 return_value = _txm_module_manager_tx_byte_pool_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
192 break;
193 }
194 #endif
195
196 #ifndef TXM_BYTE_POOL_DELETE_CALL_NOT_USED
197 case TXM_BYTE_POOL_DELETE_CALL:
198 {
199 return_value = _txm_module_manager_tx_byte_pool_delete_dispatch(module_instance, param_0);
200 break;
201 }
202 #endif
203
204 #ifndef TXM_BYTE_POOL_INFO_GET_CALL_NOT_USED
205 case TXM_BYTE_POOL_INFO_GET_CALL:
206 {
207 return_value = _txm_module_manager_tx_byte_pool_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
208 break;
209 }
210 #endif
211
212 #ifndef TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL_NOT_USED
213 case TXM_BYTE_POOL_PERFORMANCE_INFO_GET_CALL:
214 {
215 return_value = _txm_module_manager_tx_byte_pool_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
216 break;
217 }
218 #endif
219
220 #ifndef TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
221 case TXM_BYTE_POOL_PERFORMANCE_SYSTEM_INFO_GET_CALL:
222 {
223 return_value = _txm_module_manager_tx_byte_pool_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
224 break;
225 }
226 #endif
227
228 #ifndef TXM_BYTE_POOL_PRIORITIZE_CALL_NOT_USED
229 case TXM_BYTE_POOL_PRIORITIZE_CALL:
230 {
231 return_value = _txm_module_manager_tx_byte_pool_prioritize_dispatch(module_instance, param_0);
232 break;
233 }
234 #endif
235
236 #ifndef TXM_BYTE_RELEASE_CALL_NOT_USED
237 case TXM_BYTE_RELEASE_CALL:
238 {
239 return_value = _txm_module_manager_tx_byte_release_dispatch(module_instance, param_0);
240 break;
241 }
242 #endif
243
244 #ifndef TXM_EVENT_FLAGS_CREATE_CALL_NOT_USED
245 case TXM_EVENT_FLAGS_CREATE_CALL:
246 {
247 return_value = _txm_module_manager_tx_event_flags_create_dispatch(module_instance, param_0, param_1, param_2);
248 break;
249 }
250 #endif
251
252 #ifndef TXM_EVENT_FLAGS_DELETE_CALL_NOT_USED
253 case TXM_EVENT_FLAGS_DELETE_CALL:
254 {
255 return_value = _txm_module_manager_tx_event_flags_delete_dispatch(module_instance, param_0);
256 break;
257 }
258 #endif
259
260 #ifndef TXM_EVENT_FLAGS_GET_CALL_NOT_USED
261 case TXM_EVENT_FLAGS_GET_CALL:
262 {
263 return_value = _txm_module_manager_tx_event_flags_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
264 break;
265 }
266 #endif
267
268 #ifndef TXM_EVENT_FLAGS_INFO_GET_CALL_NOT_USED
269 case TXM_EVENT_FLAGS_INFO_GET_CALL:
270 {
271 return_value = _txm_module_manager_tx_event_flags_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
272 break;
273 }
274 #endif
275
276 #ifndef TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL_NOT_USED
277 case TXM_EVENT_FLAGS_PERFORMANCE_INFO_GET_CALL:
278 {
279 return_value = _txm_module_manager_tx_event_flags_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
280 break;
281 }
282 #endif
283
284 #ifndef TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
285 case TXM_EVENT_FLAGS_PERFORMANCE_SYSTEM_INFO_GET_CALL:
286 {
287 return_value = _txm_module_manager_tx_event_flags_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
288 break;
289 }
290 #endif
291
292 #ifndef TXM_EVENT_FLAGS_SET_CALL_NOT_USED
293 case TXM_EVENT_FLAGS_SET_CALL:
294 {
295 return_value = _txm_module_manager_tx_event_flags_set_dispatch(module_instance, param_0, param_1, param_2);
296 break;
297 }
298 #endif
299
300 #ifndef TXM_EVENT_FLAGS_SET_NOTIFY_CALL_NOT_USED
301 case TXM_EVENT_FLAGS_SET_NOTIFY_CALL:
302 {
303 return_value = _txm_module_manager_tx_event_flags_set_notify_dispatch(module_instance, param_0, param_1);
304 break;
305 }
306 #endif
307
308 #ifndef TXM_MUTEX_CREATE_CALL_NOT_USED
309 case TXM_MUTEX_CREATE_CALL:
310 {
311 return_value = _txm_module_manager_tx_mutex_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
312 break;
313 }
314 #endif
315
316 #ifndef TXM_MUTEX_DELETE_CALL_NOT_USED
317 case TXM_MUTEX_DELETE_CALL:
318 {
319 return_value = _txm_module_manager_tx_mutex_delete_dispatch(module_instance, param_0);
320 break;
321 }
322 #endif
323
324 #ifndef TXM_MUTEX_GET_CALL_NOT_USED
325 case TXM_MUTEX_GET_CALL:
326 {
327 return_value = _txm_module_manager_tx_mutex_get_dispatch(module_instance, param_0, param_1);
328 break;
329 }
330 #endif
331
332 #ifndef TXM_MUTEX_INFO_GET_CALL_NOT_USED
333 case TXM_MUTEX_INFO_GET_CALL:
334 {
335 return_value = _txm_module_manager_tx_mutex_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
336 break;
337 }
338 #endif
339
340 #ifndef TXM_MUTEX_PERFORMANCE_INFO_GET_CALL_NOT_USED
341 case TXM_MUTEX_PERFORMANCE_INFO_GET_CALL:
342 {
343 return_value = _txm_module_manager_tx_mutex_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
344 break;
345 }
346 #endif
347
348 #ifndef TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
349 case TXM_MUTEX_PERFORMANCE_SYSTEM_INFO_GET_CALL:
350 {
351 return_value = _txm_module_manager_tx_mutex_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
352 break;
353 }
354 #endif
355
356 #ifndef TXM_MUTEX_PRIORITIZE_CALL_NOT_USED
357 case TXM_MUTEX_PRIORITIZE_CALL:
358 {
359 return_value = _txm_module_manager_tx_mutex_prioritize_dispatch(module_instance, param_0);
360 break;
361 }
362 #endif
363
364 #ifndef TXM_MUTEX_PUT_CALL_NOT_USED
365 case TXM_MUTEX_PUT_CALL:
366 {
367 return_value = _txm_module_manager_tx_mutex_put_dispatch(module_instance, param_0);
368 break;
369 }
370 #endif
371
372 #ifndef TXM_QUEUE_CREATE_CALL_NOT_USED
373 case TXM_QUEUE_CREATE_CALL:
374 {
375 return_value = _txm_module_manager_tx_queue_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
376 break;
377 }
378 #endif
379
380 #ifndef TXM_QUEUE_DELETE_CALL_NOT_USED
381 case TXM_QUEUE_DELETE_CALL:
382 {
383 return_value = _txm_module_manager_tx_queue_delete_dispatch(module_instance, param_0);
384 break;
385 }
386 #endif
387
388 #ifndef TXM_QUEUE_FLUSH_CALL_NOT_USED
389 case TXM_QUEUE_FLUSH_CALL:
390 {
391 return_value = _txm_module_manager_tx_queue_flush_dispatch(module_instance, param_0);
392 break;
393 }
394 #endif
395
396 #ifndef TXM_QUEUE_FRONT_SEND_CALL_NOT_USED
397 case TXM_QUEUE_FRONT_SEND_CALL:
398 {
399 return_value = _txm_module_manager_tx_queue_front_send_dispatch(module_instance, param_0, param_1, param_2);
400 break;
401 }
402 #endif
403
404 #ifndef TXM_QUEUE_INFO_GET_CALL_NOT_USED
405 case TXM_QUEUE_INFO_GET_CALL:
406 {
407 return_value = _txm_module_manager_tx_queue_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
408 break;
409 }
410 #endif
411
412 #ifndef TXM_QUEUE_PERFORMANCE_INFO_GET_CALL_NOT_USED
413 case TXM_QUEUE_PERFORMANCE_INFO_GET_CALL:
414 {
415 return_value = _txm_module_manager_tx_queue_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
416 break;
417 }
418 #endif
419
420 #ifndef TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
421 case TXM_QUEUE_PERFORMANCE_SYSTEM_INFO_GET_CALL:
422 {
423 return_value = _txm_module_manager_tx_queue_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
424 break;
425 }
426 #endif
427
428 #ifndef TXM_QUEUE_PRIORITIZE_CALL_NOT_USED
429 case TXM_QUEUE_PRIORITIZE_CALL:
430 {
431 return_value = _txm_module_manager_tx_queue_prioritize_dispatch(module_instance, param_0);
432 break;
433 }
434 #endif
435
436 #ifndef TXM_QUEUE_RECEIVE_CALL_NOT_USED
437 case TXM_QUEUE_RECEIVE_CALL:
438 {
439 return_value = _txm_module_manager_tx_queue_receive_dispatch(module_instance, param_0, param_1, param_2);
440 break;
441 }
442 #endif
443
444 #ifndef TXM_QUEUE_SEND_CALL_NOT_USED
445 case TXM_QUEUE_SEND_CALL:
446 {
447 return_value = _txm_module_manager_tx_queue_send_dispatch(module_instance, param_0, param_1, param_2);
448 break;
449 }
450 #endif
451
452 #ifndef TXM_QUEUE_SEND_NOTIFY_CALL_NOT_USED
453 case TXM_QUEUE_SEND_NOTIFY_CALL:
454 {
455 return_value = _txm_module_manager_tx_queue_send_notify_dispatch(module_instance, param_0, param_1);
456 break;
457 }
458 #endif
459
460 #ifndef TXM_SEMAPHORE_CEILING_PUT_CALL_NOT_USED
461 case TXM_SEMAPHORE_CEILING_PUT_CALL:
462 {
463 return_value = _txm_module_manager_tx_semaphore_ceiling_put_dispatch(module_instance, param_0, param_1);
464 break;
465 }
466 #endif
467
468 #ifndef TXM_SEMAPHORE_CREATE_CALL_NOT_USED
469 case TXM_SEMAPHORE_CREATE_CALL:
470 {
471 return_value = _txm_module_manager_tx_semaphore_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
472 break;
473 }
474 #endif
475
476 #ifndef TXM_SEMAPHORE_DELETE_CALL_NOT_USED
477 case TXM_SEMAPHORE_DELETE_CALL:
478 {
479 return_value = _txm_module_manager_tx_semaphore_delete_dispatch(module_instance, param_0);
480 break;
481 }
482 #endif
483
484 #ifndef TXM_SEMAPHORE_GET_CALL_NOT_USED
485 case TXM_SEMAPHORE_GET_CALL:
486 {
487 return_value = _txm_module_manager_tx_semaphore_get_dispatch(module_instance, param_0, param_1);
488 break;
489 }
490 #endif
491
492 #ifndef TXM_SEMAPHORE_INFO_GET_CALL_NOT_USED
493 case TXM_SEMAPHORE_INFO_GET_CALL:
494 {
495 return_value = _txm_module_manager_tx_semaphore_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
496 break;
497 }
498 #endif
499
500 #ifndef TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL_NOT_USED
501 case TXM_SEMAPHORE_PERFORMANCE_INFO_GET_CALL:
502 {
503 return_value = _txm_module_manager_tx_semaphore_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
504 break;
505 }
506 #endif
507
508 #ifndef TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
509 case TXM_SEMAPHORE_PERFORMANCE_SYSTEM_INFO_GET_CALL:
510 {
511 return_value = _txm_module_manager_tx_semaphore_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
512 break;
513 }
514 #endif
515
516 #ifndef TXM_SEMAPHORE_PRIORITIZE_CALL_NOT_USED
517 case TXM_SEMAPHORE_PRIORITIZE_CALL:
518 {
519 return_value = _txm_module_manager_tx_semaphore_prioritize_dispatch(module_instance, param_0);
520 break;
521 }
522 #endif
523
524 #ifndef TXM_SEMAPHORE_PUT_CALL_NOT_USED
525 case TXM_SEMAPHORE_PUT_CALL:
526 {
527 return_value = _txm_module_manager_tx_semaphore_put_dispatch(module_instance, param_0);
528 break;
529 }
530 #endif
531
532 #ifndef TXM_SEMAPHORE_PUT_NOTIFY_CALL_NOT_USED
533 case TXM_SEMAPHORE_PUT_NOTIFY_CALL:
534 {
535 return_value = _txm_module_manager_tx_semaphore_put_notify_dispatch(module_instance, param_0, param_1);
536 break;
537 }
538 #endif
539
540 #ifndef TXM_THREAD_CREATE_CALL_NOT_USED
541 case TXM_THREAD_CREATE_CALL:
542 {
543 return_value = _txm_module_manager_tx_thread_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
544 break;
545 }
546 #endif
547
548 #ifndef TXM_THREAD_DELETE_CALL_NOT_USED
549 case TXM_THREAD_DELETE_CALL:
550 {
551 return_value = _txm_module_manager_tx_thread_delete_dispatch(module_instance, param_0);
552 break;
553 }
554 #endif
555
556 #ifndef TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL_NOT_USED
557 case TXM_THREAD_ENTRY_EXIT_NOTIFY_CALL:
558 {
559 return_value = _txm_module_manager_tx_thread_entry_exit_notify_dispatch(module_instance, param_0, param_1);
560 break;
561 }
562 #endif
563
564 #ifndef TXM_THREAD_IDENTIFY_CALL_NOT_USED
565 case TXM_THREAD_IDENTIFY_CALL:
566 {
567 return_value = _txm_module_manager_tx_thread_identify_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
568 break;
569 }
570 #endif
571
572 #ifndef TXM_THREAD_INFO_GET_CALL_NOT_USED
573 case TXM_THREAD_INFO_GET_CALL:
574 {
575 return_value = _txm_module_manager_tx_thread_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
576 break;
577 }
578 #endif
579
580 #ifndef TXM_THREAD_INTERRUPT_CONTROL_CALL_NOT_USED
581 case TXM_THREAD_INTERRUPT_CONTROL_CALL:
582 {
583 return_value = _txm_module_manager_tx_thread_interrupt_control_dispatch(module_instance, param_0);
584 break;
585 }
586 #endif
587
588 #ifndef TXM_THREAD_PERFORMANCE_INFO_GET_CALL_NOT_USED
589 case TXM_THREAD_PERFORMANCE_INFO_GET_CALL:
590 {
591 return_value = _txm_module_manager_tx_thread_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
592 break;
593 }
594 #endif
595
596 #ifndef TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
597 case TXM_THREAD_PERFORMANCE_SYSTEM_INFO_GET_CALL:
598 {
599 return_value = _txm_module_manager_tx_thread_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
600 break;
601 }
602 #endif
603
604 #ifndef TXM_THREAD_PREEMPTION_CHANGE_CALL_NOT_USED
605 case TXM_THREAD_PREEMPTION_CHANGE_CALL:
606 {
607 return_value = _txm_module_manager_tx_thread_preemption_change_dispatch(module_instance, param_0, param_1, param_2);
608 break;
609 }
610 #endif
611
612 #ifndef TXM_THREAD_PRIORITY_CHANGE_CALL_NOT_USED
613 case TXM_THREAD_PRIORITY_CHANGE_CALL:
614 {
615 return_value = _txm_module_manager_tx_thread_priority_change_dispatch(module_instance, param_0, param_1, param_2);
616 break;
617 }
618 #endif
619
620 #ifndef TXM_THREAD_RELINQUISH_CALL_NOT_USED
621 case TXM_THREAD_RELINQUISH_CALL:
622 {
623 return_value = _txm_module_manager_tx_thread_relinquish_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
624 break;
625 }
626 #endif
627
628 #ifndef TXM_THREAD_RESET_CALL_NOT_USED
629 case TXM_THREAD_RESET_CALL:
630 {
631 return_value = _txm_module_manager_tx_thread_reset_dispatch(module_instance, param_0);
632 break;
633 }
634 #endif
635
636 #ifndef TXM_THREAD_RESUME_CALL_NOT_USED
637 case TXM_THREAD_RESUME_CALL:
638 {
639 return_value = _txm_module_manager_tx_thread_resume_dispatch(module_instance, param_0);
640 break;
641 }
642 #endif
643
644 #ifndef TXM_THREAD_SLEEP_CALL_NOT_USED
645 case TXM_THREAD_SLEEP_CALL:
646 {
647 return_value = _txm_module_manager_tx_thread_sleep_dispatch(module_instance, param_0);
648 break;
649 }
650 #endif
651
652 #ifndef TXM_THREAD_STACK_ERROR_NOTIFY_CALL_NOT_USED
653 case TXM_THREAD_STACK_ERROR_NOTIFY_CALL:
654 {
655 return_value = _txm_module_manager_tx_thread_stack_error_notify_dispatch(module_instance, param_0);
656 break;
657 }
658 #endif
659
660 #ifndef TXM_THREAD_SUSPEND_CALL_NOT_USED
661 case TXM_THREAD_SUSPEND_CALL:
662 {
663 return_value = _txm_module_manager_tx_thread_suspend_dispatch(module_instance, param_0);
664 break;
665 }
666 #endif
667
668 #ifndef TXM_THREAD_SYSTEM_SUSPEND_CALL_NOT_USED
669 case TXM_THREAD_SYSTEM_SUSPEND_CALL:
670 {
671 return_value = _txm_module_manager_tx_thread_system_suspend_dispatch(module_instance, param_0);
672 break;
673 }
674 #endif
675
676 #ifndef TXM_THREAD_TERMINATE_CALL_NOT_USED
677 case TXM_THREAD_TERMINATE_CALL:
678 {
679 return_value = _txm_module_manager_tx_thread_terminate_dispatch(module_instance, param_0);
680 break;
681 }
682 #endif
683
684 #ifndef TXM_THREAD_TIME_SLICE_CHANGE_CALL_NOT_USED
685 case TXM_THREAD_TIME_SLICE_CHANGE_CALL:
686 {
687 return_value = _txm_module_manager_tx_thread_time_slice_change_dispatch(module_instance, param_0, param_1, param_2);
688 break;
689 }
690 #endif
691
692 #ifndef TXM_THREAD_WAIT_ABORT_CALL_NOT_USED
693 case TXM_THREAD_WAIT_ABORT_CALL:
694 {
695 return_value = _txm_module_manager_tx_thread_wait_abort_dispatch(module_instance, param_0);
696 break;
697 }
698 #endif
699
700 #ifndef TXM_TIME_GET_CALL_NOT_USED
701 case TXM_TIME_GET_CALL:
702 {
703 return_value = _txm_module_manager_tx_time_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
704 break;
705 }
706 #endif
707
708 #ifndef TXM_TIME_SET_CALL_NOT_USED
709 case TXM_TIME_SET_CALL:
710 {
711 return_value = _txm_module_manager_tx_time_set_dispatch(module_instance, param_0);
712 break;
713 }
714 #endif
715
716 #ifndef TXM_TIMER_ACTIVATE_CALL_NOT_USED
717 case TXM_TIMER_ACTIVATE_CALL:
718 {
719 return_value = _txm_module_manager_tx_timer_activate_dispatch(module_instance, param_0);
720 break;
721 }
722 #endif
723
724 #ifndef TXM_TIMER_CHANGE_CALL_NOT_USED
725 case TXM_TIMER_CHANGE_CALL:
726 {
727 return_value = _txm_module_manager_tx_timer_change_dispatch(module_instance, param_0, param_1, param_2);
728 break;
729 }
730 #endif
731
732 #ifndef TXM_TIMER_CREATE_CALL_NOT_USED
733 case TXM_TIMER_CREATE_CALL:
734 {
735 return_value = _txm_module_manager_tx_timer_create_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
736 break;
737 }
738 #endif
739
740 #ifndef TXM_TIMER_DEACTIVATE_CALL_NOT_USED
741 case TXM_TIMER_DEACTIVATE_CALL:
742 {
743 return_value = _txm_module_manager_tx_timer_deactivate_dispatch(module_instance, param_0);
744 break;
745 }
746 #endif
747
748 #ifndef TXM_TIMER_DELETE_CALL_NOT_USED
749 case TXM_TIMER_DELETE_CALL:
750 {
751 return_value = _txm_module_manager_tx_timer_delete_dispatch(module_instance, param_0);
752 break;
753 }
754 #endif
755
756 #ifndef TXM_TIMER_INFO_GET_CALL_NOT_USED
757 case TXM_TIMER_INFO_GET_CALL:
758 {
759 return_value = _txm_module_manager_tx_timer_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
760 break;
761 }
762 #endif
763
764 #ifndef TXM_TIMER_PERFORMANCE_INFO_GET_CALL_NOT_USED
765 case TXM_TIMER_PERFORMANCE_INFO_GET_CALL:
766 {
767 return_value = _txm_module_manager_tx_timer_performance_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
768 break;
769 }
770 #endif
771
772 #ifndef TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL_NOT_USED
773 case TXM_TIMER_PERFORMANCE_SYSTEM_INFO_GET_CALL:
774 {
775 return_value = _txm_module_manager_tx_timer_performance_system_info_get_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
776 break;
777 }
778 #endif
779
780 #ifndef TXM_TRACE_BUFFER_FULL_NOTIFY_CALL_NOT_USED
781 case TXM_TRACE_BUFFER_FULL_NOTIFY_CALL:
782 {
783 return_value = _txm_module_manager_tx_trace_buffer_full_notify_dispatch(module_instance, param_0);
784 break;
785 }
786 #endif
787
788 #ifndef TXM_TRACE_DISABLE_CALL_NOT_USED
789 case TXM_TRACE_DISABLE_CALL:
790 {
791 return_value = _txm_module_manager_tx_trace_disable_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
792 break;
793 }
794 #endif
795
796 #ifndef TXM_TRACE_ENABLE_CALL_NOT_USED
797 case TXM_TRACE_ENABLE_CALL:
798 {
799 return_value = _txm_module_manager_tx_trace_enable_dispatch(module_instance, param_0, param_1, param_2);
800 break;
801 }
802 #endif
803
804 #ifndef TXM_TRACE_EVENT_FILTER_CALL_NOT_USED
805 case TXM_TRACE_EVENT_FILTER_CALL:
806 {
807 return_value = _txm_module_manager_tx_trace_event_filter_dispatch(module_instance, param_0);
808 break;
809 }
810 #endif
811
812 #ifndef TXM_TRACE_EVENT_UNFILTER_CALL_NOT_USED
813 case TXM_TRACE_EVENT_UNFILTER_CALL:
814 {
815 return_value = _txm_module_manager_tx_trace_event_unfilter_dispatch(module_instance, param_0);
816 break;
817 }
818 #endif
819
820 #ifndef TXM_TRACE_INTERRUPT_CONTROL_CALL_NOT_USED
821 case TXM_TRACE_INTERRUPT_CONTROL_CALL:
822 {
823 return_value = _txm_module_manager_tx_trace_interrupt_control_dispatch(module_instance, param_0);
824 break;
825 }
826 #endif
827
828 #ifndef TXM_TRACE_ISR_ENTER_INSERT_CALL_NOT_USED
829 case TXM_TRACE_ISR_ENTER_INSERT_CALL:
830 {
831 return_value = _txm_module_manager_tx_trace_isr_enter_insert_dispatch(module_instance, param_0);
832 break;
833 }
834 #endif
835
836 #ifndef TXM_TRACE_ISR_EXIT_INSERT_CALL_NOT_USED
837 case TXM_TRACE_ISR_EXIT_INSERT_CALL:
838 {
839 return_value = _txm_module_manager_tx_trace_isr_exit_insert_dispatch(module_instance, param_0);
840 break;
841 }
842 #endif
843
844 #ifndef TXM_TRACE_USER_EVENT_INSERT_CALL_NOT_USED
845 case TXM_TRACE_USER_EVENT_INSERT_CALL:
846 {
847 return_value = _txm_module_manager_tx_trace_user_event_insert_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
848 break;
849 }
850 #endif
851
852 #ifndef TXM_MODULE_OBJECT_ALLOCATE_CALL_NOT_USED
853 case TXM_MODULE_OBJECT_ALLOCATE_CALL:
854 {
855 return_value = _txm_module_manager_txm_module_object_allocate_dispatch(module_instance, param_0, param_1);
856 break;
857 }
858 #endif
859
860 #ifndef TXM_MODULE_OBJECT_DEALLOCATE_CALL_NOT_USED
861 case TXM_MODULE_OBJECT_DEALLOCATE_CALL:
862 {
863 return_value = _txm_module_manager_txm_module_object_deallocate_dispatch(module_instance, param_0);
864 break;
865 }
866 #endif
867
868 #ifndef TXM_MODULE_OBJECT_POINTER_GET_CALL_NOT_USED
869 case TXM_MODULE_OBJECT_POINTER_GET_CALL:
870 {
871 return_value = _txm_module_manager_txm_module_object_pointer_get_dispatch(module_instance, param_0, param_1, param_2);
872 break;
873 }
874 #endif
875
876 #ifndef TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL_NOT_USED
877 case TXM_MODULE_OBJECT_POINTER_GET_EXTENDED_CALL:
878 {
879 return_value = _txm_module_manager_txm_module_object_pointer_get_extended_dispatch(module_instance, param_0, param_1, (ALIGN_TYPE *) param_2);
880 break;
881 }
882 #endif
883
884 default:
885 {
886 #ifdef TXM_MODULE_PORT_DISPATCH
887 /* Is this a port-specific request? */
888 if ((kernel_request >= TXM_MODULE_PORT_EXTENSION_API_ID_START) && (kernel_request <= TXM_MODULE_PORT_EXTENSION_API_ID_END))
889 {
890 /* Yes, call the port-specific dispatcher. */
891 return_value = (ALIGN_TYPE) _txm_module_manager_port_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
892 }
893 #endif
894
895 #ifndef TXM_MODULE_APPLICATION_REQUEST_CALL_NOT_USED
896 /* Determine if an application request is present. */
897 if (kernel_request >= TXM_APPLICATION_REQUEST_ID_BASE)
898 {
899 /* Yes, call the module manager function that the application defines in order to
900 support application-specific requests. */
901 return_value = (ALIGN_TYPE) _txm_module_manager_application_request(kernel_request-TXM_APPLICATION_REQUEST_ID_BASE, param_0, param_1, param_2);
902 }
903 #endif
904
905 #ifdef TXM_MODULE_ENABLE_NETX
906 /* Determine if there is a NetX request. */
907 else if ((kernel_request >= TXM_NETX_API_ID_START) && (kernel_request < TXM_NETX_API_ID_END))
908 {
909 /* Call the NetX module dispatch function. */
910 return_value = _txm_module_manager_netx_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
911 }
912 #endif
913
914 #ifdef TXM_MODULE_ENABLE_NETXDUO
915 /* Determine if there is a NetX Duo request. */
916 else if ((kernel_request >= TXM_NETXDUO_API_ID_START) && (kernel_request < TXM_NETXDUO_API_ID_END))
917 {
918 /* Call the NetX Duo module dispatch function. */
919 return_value = _txm_module_manager_netxduo_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
920 }
921 #endif
922
923 #ifdef TXM_MODULE_ENABLE_FILEX
924 /* Determine if there is a FileX request. */
925 else if ((kernel_request >= TXM_FILEX_API_ID_START) && (kernel_request < TXM_FILEX_API_ID_END))
926 {
927 /* Call the FileX module dispatch function. */
928 return_value = _txm_module_manager_filex_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
929 }
930 #endif
931
932 #ifdef TXM_MODULE_ENABLE_GUIX
933 /* Determine if there is a GUIX request. */
934 else if ((kernel_request >= TXM_GUIX_API_ID_START) && (kernel_request < TXM_GUIX_API_ID_END))
935 {
936 /* Call the GUIX module dispatch function. */
937 return_value = _txm_module_manager_guix_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
938 }
939 #endif
940
941 #ifdef TXM_MODULE_ENABLE_USBX
942 /* Determine if there is a USBX request. */
943 else if ((kernel_request >= TXM_USBX_API_ID_START) && (kernel_request < TXM_USBX_API_ID_END))
944 {
945 /* Call the USBX dispatch function. */
946 return_value = _txm_module_manager_usbx_dispatch(module_instance, kernel_request, param_0, param_1, param_2);
947 }
948 #endif
949
950 /* Unhandled kernel request, return an error! */
951 break;
952 }
953 }
954
955 return(return_value);
956 }
957
