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