rtai-core/include/rtai_lxrt.h

Go to the documentation of this file.
00001 
00066 #ifndef _RTAI_LXRT_H
00067 #define _RTAI_LXRT_H
00068 
00069 #include <rtai_sched.h>
00070 #include <rtai_nam2num.h>
00071 
00072 // scheduler
00073 #define YIELD                            0
00074 #define SUSPEND                          1
00075 #define RESUME                           2
00076 #define MAKE_PERIODIC                    3
00077 #define WAIT_PERIOD                      4
00078 #define SLEEP                            5
00079 #define SLEEP_UNTIL                      6
00080 #define START_TIMER                      7
00081 #define STOP_TIMER                       8
00082 #define GET_TIME                         9
00083 #define COUNT2NANO                      10
00084 #define NANO2COUNT                      11
00085 #define BUSY_SLEEP                      12
00086 #define SET_PERIODIC_MODE               13
00087 #define SET_ONESHOT_MODE                14
00088 #define SIGNAL_HANDLER                  15
00089 #define TASK_USE_FPU                    16
00090 #define LINUX_USE_FPU                   17
00091 #define PREEMPT_ALWAYS_GEN              18
00092 #define GET_TIME_NS                     19
00093 #define GET_CPU_TIME_NS                 20
00094 #define SET_RUNNABLE_ON_CPUS            21 
00095 #define SET_RUNNABLE_ON_CPUID           22       
00096 #define GET_TIMER_CPU                   23       
00097 #define START_RT_APIC_TIMERS            24
00098 #define PREEMPT_ALWAYS_CPUID            25
00099 #define COUNT2NANO_CPUID                26
00100 #define NANO2COUNT_CPUID                27
00101 #define GET_TIME_CPUID                  28
00102 #define GET_TIME_NS_CPUID               29
00103 #define MAKE_PERIODIC_NS                30
00104 #define SET_SCHED_POLICY                31
00105 #define SET_RESUME_END                  32
00106 #define SPV_RMS                         33
00107 #define WAKEUP_SLEEPING                 34
00108 #define CHANGE_TASK_PRIO                35
00109 #define SET_RESUME_TIME                 36
00110 #define SET_PERIOD                      37
00111 #define HARD_TIMER_RUNNING              38
00112 
00113 // semaphores
00114 #define TYPED_SEM_INIT                  39
00115 #define SEM_DELETE                      40
00116 #define NAMED_SEM_INIT                  41
00117 #define NAMED_SEM_DELETE                42
00118 #define SEM_SIGNAL                      43
00119 #define SEM_WAIT                        44
00120 #define SEM_WAIT_IF                     45
00121 #define SEM_WAIT_UNTIL                  46
00122 #define SEM_WAIT_TIMED                  47
00123 #define SEM_BROADCAST                   48
00124 #define SEM_WAIT_BARRIER                49
00125 #define SEM_COUNT                       50
00126 #define COND_WAIT                       51
00127 #define COND_WAIT_UNTIL                 52
00128 #define COND_WAIT_TIMED                 53
00129 #define RWL_INIT                        54
00130 #define RWL_DELETE                      55
00131 #define NAMED_RWL_INIT                  56
00132 #define NAMED_RWL_DELETE                57
00133 #define RWL_RDLOCK                      58
00134 #define RWL_RDLOCK_IF                   59
00135 #define RWL_RDLOCK_UNTIL                60
00136 #define RWL_RDLOCK_TIMED                61
00137 #define RWL_WRLOCK                      62      
00138 #define RWL_WRLOCK_IF                   63
00139 #define RWL_WRLOCK_UNTIL                64
00140 #define RWL_WRLOCK_TIMED                65
00141 #define RWL_UNLOCK                      66
00142 #define SPL_INIT                        67
00143 #define SPL_DELETE                      68
00144 #define NAMED_SPL_INIT                  69
00145 #define NAMED_SPL_DELETE                70
00146 #define SPL_LOCK                        71      
00147 #define SPL_LOCK_IF                     72
00148 #define SPL_LOCK_TIMED                  73
00149 #define SPL_UNLOCK                      74
00150 
00151 // mail boxes
00152 #define TYPED_MBX_INIT                  75
00153 #define MBX_DELETE                      76
00154 #define NAMED_MBX_INIT                  77
00155 #define NAMED_MBX_DELETE                78
00156 #define MBX_SEND                        79
00157 #define MBX_SEND_WP                     80
00158 #define MBX_SEND_IF                     81
00159 #define MBX_SEND_UNTIL                  82
00160 #define MBX_SEND_TIMED                  83
00161 #define MBX_RECEIVE                     84
00162 #define MBX_RECEIVE_WP                  85
00163 #define MBX_RECEIVE_IF                  86
00164 #define MBX_RECEIVE_UNTIL               87
00165 #define MBX_RECEIVE_TIMED               88
00166 #define MBX_EVDRP                       89
00167 #define MBX_OVRWR_SEND                  90
00168 
00169 // short intertask messages
00170 #define SENDMSG                         91
00171 #define SEND_IF                         92
00172 #define SEND_UNTIL                      93
00173 #define SEND_TIMED                      94
00174 #define RECEIVEMSG                      95
00175 #define RECEIVE_IF                      96
00176 #define RECEIVE_UNTIL                   97
00177 #define RECEIVE_TIMED                   98
00178 #define RPCMSG                          99
00179 #define RPC_IF                         100
00180 #define RPC_UNTIL                      101
00181 #define RPC_TIMED                      102
00182 #define EVDRP                          103
00183 #define ISRPC                          104
00184 #define RETURNMSG                      105
00185 
00186 // extended intertask messages
00187 #define RPCX                           106
00188 #define RPCX_IF                        107
00189 #define RPCX_UNTIL                     108
00190 #define RPCX_TIMED                     109
00191 #define SENDX                          110
00192 #define SENDX_IF                       111
00193 #define SENDX_UNTIL                    112
00194 #define SENDX_TIMED                    113
00195 #define RETURNX                        114
00196 #define RECEIVEX                       115
00197 #define RECEIVEX_IF                    116
00198 #define RECEIVEX_UNTIL                 117
00199 #define RECEIVEX_TIMED                 118
00200 #define EVDRPX                         119
00201 
00202 // proxies
00203 #define PROXY_ATTACH                   120
00204 #define PROXY_DETACH                   121
00205 #define PROXY_TRIGGER                  122
00206 
00207 
00208 // synchronous user space specific intertask messages and related proxies
00209 #define RT_SEND                        123
00210 #define RT_RECEIVE                     124
00211 #define RT_CRECEIVE                    125
00212 #define RT_REPLY                       126
00213 #define RT_PROXY_ATTACH                127
00214 #define RT_PROXY_DETACH                128
00215 #define RT_TRIGGER                     129
00216 #define RT_NAME_ATTACH                 130
00217 #define RT_NAME_DETACH                 131
00218 #define RT_NAME_LOCATE                 132
00219 
00220 // bits
00221 #define BITS_INIT                      133      
00222 #define BITS_DELETE                    134
00223 #define NAMED_BITS_INIT                135
00224 #define NAMED_BITS_DELETE              136
00225 #define BITS_GET                       137
00226 #define BITS_RESET                     138
00227 #define BITS_SIGNAL                    139
00228 #define BITS_WAIT                      140
00229 #define BITS_WAIT_IF                   141              
00230 #define BITS_WAIT_UNTIL                142
00231 #define BITS_WAIT_TIMED                143
00232 
00233 // typed mail boxes
00234 #define TBX_INIT                       144
00235 #define TBX_DELETE                     145
00236 #define NAMED_TBX_INIT                 146
00237 #define NAMED_TBX_DELETE               147
00238 #define TBX_SEND                       148
00239 #define TBX_SEND_IF                    149
00240 #define TBX_SEND_UNTIL                 150
00241 #define TBX_SEND_TIMED                 151
00242 #define TBX_RECEIVE                    152
00243 #define TBX_RECEIVE_IF                 153
00244 #define TBX_RECEIVE_UNTIL              154
00245 #define TBX_RECEIVE_TIMED              155
00246 #define TBX_BROADCAST                  156
00247 #define TBX_BROADCAST_IF               157
00248 #define TBX_BROADCAST_UNTIL            158
00249 #define TBX_BROADCAST_TIMED            159
00250 #define TBX_URGENT                     160
00251 #define TBX_URGENT_IF                  161
00252 #define TBX_URGENT_UNTIL               162
00253 #define TBX_URGENT_TIMED               163
00254 
00255 // pqueue
00256 #define MQ_OPEN                        164
00257 #define MQ_RECEIVE                     165
00258 #define MQ_SEND                        166
00259 #define MQ_CLOSE                       167
00260 #define MQ_GETATTR                     168
00261 #define MQ_SETATTR                     169
00262 #define MQ_NOTIFY                      170
00263 #define MQ_UNLINK                      171
00264 #define MQ_TIMEDRECEIVE                172
00265 #define MQ_TIMEDSEND                   173
00266 
00267 // named tasks init/delete
00268 #define NAMED_TASK_INIT                174
00269 #define NAMED_TASK_INIT_CPUID          175
00270 #define NAMED_TASK_DELETE              176
00271 
00272 // registry
00273 #define GET_ADR                        177
00274 #define GET_NAME                       178
00275 
00276 // netrpc
00277 #define NETRPC                         179
00278 #define SEND_REQ_REL_PORT              180
00279 #define DDN2NL                         181
00280 #define SET_THIS_NODE                  182
00281 #define FIND_ASGN_STUB                 183
00282 #define REL_STUB                       184      
00283 #define WAITING_RETURN                 185
00284 
00285 // a semaphore extension
00286 #define COND_SIGNAL                    186
00287 
00288 // new shm
00289 #define SHM_ALLOC                      187
00290 #define SHM_FREE                       188
00291 #define SHM_SIZE                       189
00292 #define HEAP_SET                       190
00293 #define HEAP_ALLOC                     191
00294 #define HEAP_FREE                      192
00295 #define HEAP_NAMED_ALLOC               193
00296 #define HEAP_NAMED_FREE                194
00297 #define MALLOC                         195
00298 #define FREE                           196
00299 #define NAMED_MALLOC                   197
00300 #define NAMED_FREE                     198
00301 
00302 #define MAX_LXRT_FUN                   200
00303 
00304 // not recovered yet 
00305 // Qblk's 
00306 #define RT_INITTICKQUEUE                69
00307 #define RT_RELEASETICKQUEUE             70
00308 #define RT_QDYNALLOC                    71
00309 #define RT_QDYNFREE                     72
00310 #define RT_QDYNINIT                     73
00311 #define RT_QBLKWAIT                     74
00312 #define RT_QBLKREPEAT                   75
00313 #define RT_QBLKSOON                     76
00314 #define RT_QBLKDEQUEUE                  77
00315 #define RT_QBLKCANCEL                   78
00316 #define RT_QSYNC                        79
00317 #define RT_QRECEIVE                     80
00318 #define RT_QLOOP                        81
00319 #define RT_QSTEP                        82
00320 #define RT_QBLKBEFORE                   83
00321 #define RT_QBLKAFTER                    84
00322 #define RT_QBLKUNHOOK                   85
00323 #define RT_QBLKRELEASE                  86
00324 #define RT_QBLKCOMPLETE                 87
00325 #define RT_QHOOKFLUSH                   88
00326 #define RT_QBLKATHEAD                   89
00327 #define RT_QBLKATTAIL                   90
00328 #define RT_QHOOKINIT                    91
00329 #define RT_QHOOKRELEASE                 92
00330 #define RT_QBLKSCHEDULE                 93
00331 #define RT_GETTICKQUEUEHOOK             94
00332 // Testing
00333 #define RT_BOOM                         95
00334 #define RTAI_MALLOC                     96
00335 #define RT_FREE                         97
00336 #define RT_MMGR_STATS                   98
00337 #define RT_STOMP                        99
00338 // VC
00339 #define RT_VC_ATTACH                    100
00340 #define RT_VC_RELEASE                   101
00341 #define RT_VC_RESERVE                   102
00342 // Linux Signal Support
00343 #define RT_GET_LINUX_SIGNAL             103
00344 #define RT_GET_ERRNO                    104
00345 #define RT_SET_LINUX_SIGNAL_HANDLER     105
00346 // end of not recovered yet
00347 
00348 #define LXRT_GET_ADR            1000
00349 #define LXRT_GET_NAME           1001
00350 #define LXRT_TASK_INIT          1002
00351 #define LXRT_TASK_DELETE        1003
00352 #define LXRT_SEM_INIT           1004
00353 #define LXRT_SEM_DELETE         1005
00354 #define LXRT_MBX_INIT           1006
00355 #define LXRT_MBX_DELETE         1007
00356 #define MAKE_SOFT_RT            1008
00357 #define MAKE_HARD_RT            1009
00358 #define PRINT_TO_SCREEN         1010
00359 #define NONROOT_HRT             1011
00360 #define RT_BUDDY                1012
00361 #define HRT_USE_FPU             1013
00362 #define USP_SIGHDL              1014
00363 #define GET_USP_FLAGS           1015
00364 #define SET_USP_FLAGS           1016
00365 #define GET_USP_FLG_MSK         1017
00366 #define SET_USP_FLG_MSK         1018
00367 #define IS_HARD                 1019
00368 #define LXRT_FORK               1020
00369 #define ALLOC_REGISTER          1021
00370 #define DELETE_DEREGISTER       1022
00371 #define FORCE_TASK_SOFT         1023
00372 #define PRINTK                  1024
00373 #define GET_EXECTIME            1025
00374 #define GET_TIMEORIG            1026
00375 #define LXRT_RWL_INIT           1027
00376 #define LXRT_RWL_DELETE         1028
00377 #define LXRT_SPL_INIT           1029
00378 #define LXRT_SPL_DELETE         1030
00379 
00380 #define FORCE_SOFT 0x80000000
00381 
00382 #ifdef __KERNEL__
00383 
00384 #include <asm/rtai_lxrt.h>
00385 
00386 /*
00387      Encoding of system call argument
00388             31                                    0  
00389 soft SRQ    .... |||| |||| |||| .... .... .... ....  0 - 4095 max
00390 int  NARG   .... .... .... .... |||| |||| |||| ||||  
00391 arg  INDX   |||| .... .... .... .... .... .... ....
00392 */
00393 
00394 /*
00395 These USP (unsigned long long) type fields allow to read and write up to 2 arguments.  
00396                                                
00397 RW marker .... .... .... .... .... .... .... ..|| .... .... .... .... .... .... .... ...|
00398 
00399 HIGH unsigned long encodes writes
00400 W ARG1 BF .... .... .... .... .... ...| |||| ||..
00401 W ARG1 SZ .... .... .... .... |||| |||. .... ....
00402 W ARG2 BF .... .... .||| |||| .... .... .... ....
00403 W ARG2 SZ ..|| |||| |... .... .... .... .... ....
00404 W 1st  LL .|.. .... .... .... .... .... .... ....
00405 W 2nd  LL |... .... .... .... .... .... .... ....
00406 
00407 LOW unsigned long encodes reads
00408 R ARG1 BF .... .... .... .... .... ...| |||| ||..
00409 R ARG1 SZ .... .... .... .... |||| |||. .... ....
00410 R ARG2 BF .... .... .||| |||| .... .... .... ....
00411 R ARG2 SZ ..|| |||| |... .... .... .... .... ....
00412 R 1st  LL .|.. .... .... .... .... .... .... ....
00413 R 2nd  LL |... .... .... .... .... .... .... ....
00414 
00415 LOW unsigned long encodes also
00416 RT Switch .... .... .... .... .... .... .... ...|
00417 
00418 and 
00419 Always 0  .... .... .... .... .... .... .... ..|.
00420 
00421 If SZ is zero sizeof(int) is copied by default, if LL bit is set sizeof(long long) is copied.
00422 */
00423 
00424 // These are for setting appropriate bits in any function entry structure, OR
00425 // them in fun entry type to obtain the desired encoding
00426 
00427 // for writes
00428 #define UW1(bf, sz)  ((((unsigned long long)((((bf) & 0x7F) <<  2) | (((sz) & 0x7F) <<  9))) << 32) | 0x300000001LL)
00429 #define UW2(bf, sz)  ((((unsigned long long)((((bf) & 0x7F) << 16) | (((sz) & 0x7F) << 23))) << 32) | 0x300000001LL)
00430 #define UWSZ1LL      (0x4000000300000001LL)
00431 #define UWSZ2LL      (0x8000000300000001LL)
00432 
00433 // for reads
00434 #define UR1(bf, sz)  ((((bf) & 0x7F) <<  2) | (((sz) & 0x7F) <<  9) | 0x300000001LL)
00435 #define UR2(bf, sz)  ((((bf) & 0x7F) << 16) | (((sz) & 0x7F) << 23) | 0x300000001LL)
00436 #define URSZ1LL      (0x340000001LL)
00437 #define URSZ2LL      (0x380000001LL)
00438 
00439 // and these are for deciding what to do in lxrt.c
00440 #define NEED_TO_RW(x)   (((unsigned long *)&(x))[HIGH])
00441 
00442 #define NEED_TO_R(x)    (((unsigned long *)&(x))[LOW]  & 0x0000FFFC)
00443 #define NEED_TO_W(x)    (((unsigned long *)&(x))[HIGH] & 0x0000FFFC)
00444 
00445 #define NEED_TO_R2ND(x) (((unsigned long *)&(x))[LOW]  & 0x3FFF0000)
00446 #define NEED_TO_W2ND(x) (((unsigned long *)&(x))[HIGH] & 0x3FFF0000)
00447 
00448 #define USP_RBF1(x)     ((((unsigned long *)&(x))[LOW] >>  2) & 0x7F)
00449 #define USP_RSZ1(x)     ((((unsigned long *)&(x))[LOW] >>  9) & 0x7F)
00450 #define USP_RBF2(x)     ((((unsigned long *)&(x))[LOW] >> 16) & 0x7F)
00451 #define USP_RSZ2(x)     ((((unsigned long *)&(x))[LOW] >> 23) & 0x7F)
00452 #define USP_RSZ1LL(x)   (((unsigned long *)&(x))[LOW] & 0x40000000)
00453 #define USP_RSZ2LL(x)   (((unsigned long *)&(x))[LOW] & 0x80000000)
00454 
00455 #define USP_WBF1(x)     ((((unsigned long *)&(x))[HIGH] >>  2) & 0x7F)
00456 #define USP_WSZ1(x)     ((((unsigned long *)&(x))[HIGH] >>  9) & 0x7F)
00457 #define USP_WBF2(x)     ((((unsigned long *)&(x))[HIGH] >> 16) & 0x7F)
00458 #define USP_WSZ2(x)     ((((unsigned long *)&(x))[HIGH] >> 23) & 0x7F)
00459 #define USP_WSZ1LL(x)   (((unsigned long *)&(x))[HIGH] & 0x40000000)
00460 #define USP_WSZ2LL(x)   (((unsigned long *)&(x))[HIGH] & 0x80000000)
00461 
00462 #define SRQ(x)   (((x) >> 16) & 0xFFF)
00463 #define NARG(x)  ((x) & 0xFFFF)
00464 #define INDX(x)  (((x) >> 28) & 0xF)
00465 
00466 struct rt_fun_entry {
00467     unsigned long long type;
00468     void *fun;
00469 };
00470 
00471 struct rt_native_fun_entry {
00472     struct rt_fun_entry fun;
00473     int index;
00474 };
00475 
00476 extern struct rt_fun_entry rt_fun_lxrt[];
00477 
00478 void reset_rt_fun_entries(struct rt_native_fun_entry *entry);
00479 
00480 int set_rt_fun_entries(struct rt_native_fun_entry *entry);
00481 
00482 #ifdef __cplusplus
00483 extern "C" {
00484 #endif /* __cplusplus */
00485 
00486 #if CONFIG_RTAI_INTERNAL_LXRT_SUPPORT
00487  
00488 static inline struct rt_task_struct *pid2rttask(pid_t pid)
00489 {
00490         return ((unsigned long)pid) > PID_MAX_LIMIT ? (struct rt_task_struct *)pid : find_task_by_pid(pid)->this_rt_task[0];
00491 }
00492 
00493 static inline pid_t rttask2pid(struct rt_task_struct * task)
00494 {
00495     return task->lnxtsk ? task->lnxtsk->pid : (int) task;
00496 }
00497 
00498 #else /* !CONFIG_RTAI_INTERNAL_LXRT_SUPPORT */
00499 
00500 static inline struct rt_task_struct *pid2rttask(pid_t pid)
00501 {
00502     return 0;
00503 }
00504 
00505 // The following might look strange but it must be so to work with
00506 // buddies also.
00507 static inline pid_t rttask2pid(struct rt_task_struct * task)
00508 {
00509     return (int) task;
00510 }
00511 
00512 #endif /* CONFIG_RTAI_INTERNAL_LXRT_SUPPORT */
00513 
00514 int set_rtai_callback(void (*fun)(void));
00515 
00516 void remove_rtai_callback(void (*fun)(void));
00517 
00518 RT_TASK *rt_lxrt_whoami(void);
00519 
00520 void exec_func(void (*func)(void *data, int evn),
00521                void *data,
00522                int evn);
00523 
00524 int  set_rt_fun_ext_index(struct rt_fun_entry *fun,
00525                           int idx);
00526 
00527 void reset_rt_fun_ext_index(struct rt_fun_entry *fun,
00528                             int idx);
00529 
00530 #ifdef __cplusplus
00531 }
00532 #endif /* __cplusplus */
00533 
00534 #else /* !__KERNEL__ */
00535 
00536 #include <sys/types.h>
00537 #include <sched.h>
00538 #include <stdarg.h>
00539 #include <stdio.h>
00540 #include <string.h>
00541 #include <asm/rtai_lxrt.h>
00542 
00543 struct apic_timer_setup_data;
00544 
00545 #define rt_grow_and_lock_stack(incr) \
00546         do { \
00547                 char buf[incr]; \
00548                 memset(buf, 0, incr); \
00549                 mlockall(MCL_CURRENT | MCL_FUTURE); \
00550         } while (0)
00551 
00552 #define BIDX   0 // rt_fun_ext[0]
00553 #define SIZARG sizeof(arg)
00554 
00555 #ifdef __cplusplus
00556 extern "C" {
00557 #endif /* __cplusplus */
00558 
00566 RTAI_PROTO(void *,rt_get_adr,(unsigned long name))
00567 {
00568         struct { int name; } arg = { name };
00569         return rtai_lxrt(BIDX, SIZARG, LXRT_GET_ADR, &arg).v[LOW];
00570 } 
00571 
00580 RTAI_PROTO(unsigned long,rt_get_name,(void *adr))
00581 {
00582         struct { void *adr; } arg = { adr };
00583         return rtai_lxrt(BIDX, SIZARG, LXRT_GET_NAME, &arg).i[LOW];
00584 }
00585 
00586 RTAI_PROTO(RT_TASK *,rt_task_init_schmod,(int name, int priority, int stack_size, int max_msg_size, int policy, int cpus_allowed))
00587 {
00588         struct sched_param mysched;
00589         struct { int name, priority, stack_size, max_msg_size, cpus_allowed; } arg = { name, priority, stack_size, max_msg_size, cpus_allowed };
00590 
00591         mysched.sched_priority = sched_get_priority_max(policy) - priority;
00592         if (mysched.sched_priority < 1 ) {
00593                 mysched.sched_priority = 1;
00594         }
00595         if (sched_setscheduler(0, policy, &mysched) < 0) {
00596                 return 0;
00597         }
00598 
00599         return (RT_TASK *)rtai_lxrt(BIDX, SIZARG, LXRT_TASK_INIT, &arg).v[LOW];
00600 }
00601 
00602 
00656 RTAI_PROTO(RT_TASK *,rt_task_init,(int name, int priority, int stack_size, int max_msg_size))
00657 {
00658         struct { int name, priority, stack_size, max_msg_size, cpus_allowed; } arg = { name, priority, stack_size, max_msg_size, 0xFF };
00659         return (RT_TASK *)rtai_lxrt(BIDX, SIZARG, LXRT_TASK_INIT, &arg).v[LOW];
00660 }
00661 
00662 RTAI_PROTO(void,rt_set_sched_policy,(RT_TASK *task, int policy, int rr_quantum_ns))
00663 {
00664         struct { RT_TASK *task; int policy; int rr_quantum_ns; } arg = { task, policy, rr_quantum_ns };
00665         rtai_lxrt(BIDX, SIZARG, SET_SCHED_POLICY, &arg);
00666 }
00667 
00668 RTAI_PROTO(int,rt_change_prio,(RT_TASK *task, int priority))
00669 {
00670         struct { RT_TASK *task; int priority; } arg = { task, priority };
00671         return rtai_lxrt(BIDX, SIZARG, CHANGE_TASK_PRIO, &arg).i[LOW];
00672 }
00673 
00686 RTAI_PROTO(void,rt_make_soft_real_time,(void))
00687 {
00688         struct { unsigned long dummy; } arg;
00689         rtai_lxrt(BIDX, SIZARG, MAKE_SOFT_RT, &arg);
00690 }
00691 
00692 RTAI_PROTO(int,rt_task_delete,(RT_TASK *task))
00693 {
00694         struct { RT_TASK *task; } arg = { task };
00695         rt_make_soft_real_time();
00696         return rtai_lxrt(BIDX, SIZARG, LXRT_TASK_DELETE, &arg).i[LOW];
00697 }
00698 
00699 RTAI_PROTO(int,rt_task_yield,(void))
00700 {
00701         struct { unsigned long dummy; } arg;
00702         return rtai_lxrt(BIDX, SIZARG, YIELD, &arg).i[LOW];
00703 }
00704 
00705 RTAI_PROTO(int,rt_task_suspend,(RT_TASK *task))
00706 {
00707         struct { RT_TASK *task; } arg = { task };
00708         return rtai_lxrt(BIDX, SIZARG, SUSPEND, &arg).i[LOW];
00709 }
00710 
00711 RTAI_PROTO(int,rt_task_resume,(RT_TASK *task))
00712 {
00713         struct { RT_TASK *task; } arg = { task };
00714         return rtai_lxrt(BIDX, SIZARG, RESUME, &arg).i[LOW];
00715 }
00716 
00717 RTAI_PROTO(int, rt_task_make_periodic,(RT_TASK *task, RTIME start_time, RTIME period))
00718 {
00719         struct { RT_TASK *task; RTIME start_time, period; } arg = { task, start_time, period };
00720         return rtai_lxrt(BIDX, SIZARG, MAKE_PERIODIC, &arg).i[LOW];
00721 }
00722 
00723 RTAI_PROTO(int,rt_task_make_periodic_relative_ns,(RT_TASK *task, RTIME start_delay, RTIME period))
00724 {
00725         struct { RT_TASK *task; RTIME start_time, period; } arg = { task, start_delay, period };
00726         return rtai_lxrt(BIDX, SIZARG, MAKE_PERIODIC_NS, &arg).i[LOW];
00727 }
00728 
00729 RTAI_PROTO(void,rt_task_wait_period,(void))
00730 {
00731         struct { unsigned long dummy; } arg;
00732         rtai_lxrt(BIDX, SIZARG, WAIT_PERIOD, &arg);
00733 }
00734 
00735 RTAI_PROTO(void,rt_sleep,(RTIME delay))
00736 {
00737         struct { RTIME delay; } arg = { delay };
00738         rtai_lxrt(BIDX, SIZARG, SLEEP, &arg);
00739 }
00740 
00741 RTAI_PROTO(void,rt_sleep_until,(RTIME time))
00742 {
00743         struct { RTIME time; } arg = { time };
00744         rtai_lxrt(BIDX, SIZARG, SLEEP_UNTIL, &arg);
00745 }
00746 
00747 RTAI_PROTO(int,rt_is_hard_timer_running,(void))
00748 {
00749         struct { unsigned long dummy; } arg;
00750         return rtai_lxrt(BIDX, SIZARG, HARD_TIMER_RUNNING, &arg).i[LOW];
00751 }
00752 
00753 RTAI_PROTO(RTIME, start_rt_timer,(int period))
00754 {
00755         struct { int period; } arg = { period };
00756         return rtai_lxrt(BIDX, SIZARG, START_TIMER, &arg).rt;
00757 }
00758 
00759 RTAI_PROTO(void, stop_rt_timer,(void))
00760 {
00761         struct { unsigned long dummy; } arg;
00762         rtai_lxrt(BIDX, SIZARG, STOP_TIMER, &arg);
00763 }
00764 
00765 RTAI_PROTO(RTIME,rt_get_time,(void))
00766 {
00767         struct { unsigned long dummy; } arg;
00768         return rtai_lxrt(BIDX, SIZARG, GET_TIME, &arg).rt;
00769 }
00770 
00771 RTAI_PROTO(RTIME,count2nano,(RTIME count))
00772 {
00773         struct { RTIME count; } arg = { count };
00774         return rtai_lxrt(BIDX, SIZARG, COUNT2NANO, &arg).rt;
00775 }
00776 
00777 RTAI_PROTO(RTIME,nano2count,(RTIME nanos))
00778 {
00779         struct { RTIME nanos; } arg = { nanos };
00780         return rtai_lxrt(BIDX, SIZARG, NANO2COUNT, &arg).rt;
00781 }
00782 
00783 RTAI_PROTO(void,rt_busy_sleep,(int ns))
00784 {
00785         struct { int ns; } arg = { ns };
00786         rtai_lxrt(BIDX, SIZARG, BUSY_SLEEP, &arg);
00787 }
00788 
00789 RTAI_PROTO(void,rt_set_periodic_mode,(void))
00790 {
00791         struct { unsigned long dummy; } arg;
00792         rtai_lxrt(BIDX, SIZARG, SET_PERIODIC_MODE, &arg);
00793 }
00794 
00795 RTAI_PROTO(void,rt_set_oneshot_mode,(void))
00796 {
00797         struct { unsigned long dummy; } arg;
00798         rtai_lxrt(BIDX, SIZARG, SET_ONESHOT_MODE, &arg);
00799 }
00800 
00801 RTAI_PROTO(int,rt_task_signal_handler,(RT_TASK *task, void (*handler)(void)))
00802 {
00803         struct { RT_TASK *task; void (*handler)(void); } arg = { task, handler };
00804         return rtai_lxrt(BIDX, SIZARG, SIGNAL_HANDLER, &arg).i[LOW];
00805 }
00806 
00807 RTAI_PROTO(int,rt_task_use_fpu,(RT_TASK *task, int use_fpu_flag))
00808 {
00809         struct { RT_TASK *task; int use_fpu_flag; } arg = { task, use_fpu_flag };
00810         if (rtai_lxrt(BIDX, SIZARG, RT_BUDDY, &arg).v[LOW] != task) {
00811                 return rtai_lxrt(BIDX, SIZARG, TASK_USE_FPU, &arg).i[LOW];
00812         } else {
00813 // note that it would be enough to do whatever FP op here to have it OK. But
00814 // that is scary if it is done when already in hard real time, and we do not
00815 // want to force users to call this before making it hard.
00816                 rtai_lxrt(BIDX, SIZARG, HRT_USE_FPU, &arg);
00817                 return 0;
00818         }
00819 }
00820 
00821 RTAI_PROTO(int,rt_buddy_task_use_fpu,(RT_TASK *task, int use_fpu_flag))
00822 {
00823         struct { RT_TASK *task; int use_fpu_flag; } arg = { task, use_fpu_flag };
00824         return rtai_lxrt(BIDX, SIZARG, TASK_USE_FPU, &arg).i[LOW];
00825 }
00826 
00827 RTAI_PROTO(int,rt_linux_use_fpu,(int use_fpu_flag))
00828 {
00829         struct { int use_fpu_flag; } arg = { use_fpu_flag };
00830         return rtai_lxrt(BIDX, SIZARG, LINUX_USE_FPU, &arg).i[LOW];
00831 }
00832 
00833 RTAI_PROTO(void,rt_preempt_always,(int yes_no))
00834 {
00835         struct { int yes_no; } arg = { yes_no };
00836         rtai_lxrt(BIDX, SIZARG, PREEMPT_ALWAYS_GEN, &arg);
00837 }
00838 
00839 RTAI_PROTO(RTIME,rt_get_time_ns,(void))
00840 {
00841         struct { unsigned long dummy; } arg;
00842         return rtai_lxrt(BIDX, SIZARG, GET_TIME_NS, &arg).rt;
00843 }
00844 
00845 RTAI_PROTO(RTIME,rt_get_cpu_time_ns,(void))
00846 {
00847         struct { unsigned long dummy; } arg;
00848         return rtai_lxrt(BIDX, SIZARG, GET_CPU_TIME_NS, &arg).rt;
00849 }
00850 
00851 #define rt_named_task_init(task_name, thread, data, stack_size, prio, uses_fpu, signal) \
00852         rt_task_init(nam2num(task_name), thread, data, stack_size, prio, uses_fpu, signal)
00853 
00854 #define rt_named_task_init_cpuid(task_name, thread, data, stack_size, prio, uses_fpu, signal, run_on_cpu) \
00855         rt_task_init_cpuid(nam2num(task_name), thread, data, stack_size, prio, uses_fpu, signal, run_on_cpu)
00856 
00857 RTAI_PROTO(void,rt_set_runnable_on_cpus,(RT_TASK *task, unsigned long cpu_mask))
00858 {
00859         struct { RT_TASK *task; unsigned long cpu_mask; } arg = { task, cpu_mask };
00860         rtai_lxrt(BIDX, SIZARG, SET_RUNNABLE_ON_CPUS, &arg);
00861 }
00862 
00863 RTAI_PROTO(void,rt_set_runnable_on_cpuid,(RT_TASK *task, unsigned int cpuid))
00864 {
00865         struct { RT_TASK *task; unsigned int cpuid; } arg = { task, cpuid };
00866         rtai_lxrt(BIDX, SIZARG, SET_RUNNABLE_ON_CPUID, &arg);
00867 }
00868 
00869 RTAI_PROTO(int,rt_get_timer_cpu,(void))
00870 {
00871         struct { unsigned long dummy; } arg;
00872         return rtai_lxrt(BIDX, SIZARG, GET_TIMER_CPU, &arg).i[LOW];
00873 }
00874 
00875 RTAI_PROTO(void,start_rt_apic_timers,(struct apic_timer_setup_data *setup_mode, unsigned int rcvr_jiffies_cpuid))
00876 {
00877         struct { struct apic_timer_setup_data *setup_mode; unsigned int rcvr_jiffies_cpuid; } arg = { setup_mode, rcvr_jiffies_cpuid };
00878         rtai_lxrt(BIDX, SIZARG, START_RT_APIC_TIMERS, &arg);
00879 }
00880 
00881 RTAI_PROTO(void,rt_preempt_always_cpuid,(int yes_no, unsigned int cpuid))
00882 {
00883         struct { int yes_no; unsigned int cpuid; } arg = { yes_no, cpuid };
00884         rtai_lxrt(BIDX, SIZARG, PREEMPT_ALWAYS_CPUID, &arg);
00885 }
00886 
00887 RTAI_PROTO(RTIME,count2nano_cpuid,(RTIME count, unsigned int cpuid))
00888 {
00889         struct { RTIME count; unsigned int cpuid; } arg = { count, cpuid };
00890         return rtai_lxrt(BIDX, SIZARG, COUNT2NANO_CPUID, &arg).rt;
00891 }
00892 
00893 RTAI_PROTO(RTIME,nano2count_cpuid,(RTIME nanos, unsigned int cpuid))
00894 {
00895         struct { RTIME nanos; unsigned int cpuid; } arg = { nanos, cpuid };
00896         return rtai_lxrt(BIDX, SIZARG, NANO2COUNT_CPUID, &arg).rt;
00897 }
00898 
00899 RTAI_PROTO(RTIME,rt_get_time_cpuid,(unsigned int cpuid))
00900 {
00901         struct { unsigned int cpuid; } arg = { cpuid };
00902         return rtai_lxrt(BIDX, SIZARG, GET_TIME_CPUID, &arg).rt;
00903 }
00904 
00905 RTAI_PROTO(RTIME,rt_get_time_ns_cpuid,(unsigned int cpuid))
00906 {
00907         struct { unsigned int cpuid; } arg = { cpuid };
00908         return rtai_lxrt(BIDX, SIZARG, GET_TIME_NS_CPUID, &arg).rt;
00909 }
00910 
00911 RTAI_PROTO(void,rt_boom,(void))
00912 {
00913         struct { int dummy; } arg = { 0 };
00914         rtai_lxrt(BIDX, SIZARG, RT_BOOM, &arg);
00915 }
00916 
00917 RTAI_PROTO(void,rt_mmgr_stats,(void))
00918 {
00919         struct { int dummy; } arg = { 0 };
00920         rtai_lxrt(BIDX, SIZARG, RT_MMGR_STATS, &arg);
00921 }
00922 
00923 RTAI_PROTO(void,rt_stomp,(void) )
00924 {
00925         struct { int dummy; } arg = { 0 };
00926         rtai_lxrt(BIDX, SIZARG, RT_STOMP, &arg);
00927 }
00928 
00929 RTAI_PROTO(int,rt_get_linux_signal,(RT_TASK *task))
00930 {
00931     struct { RT_TASK *task; } arg = { task };
00932     return rtai_lxrt(BIDX, SIZARG, RT_GET_LINUX_SIGNAL, &arg).i[LOW];
00933 }
00934 
00935 RTAI_PROTO(int,rt_get_errno,(RT_TASK *task))
00936 {
00937     struct { RT_TASK *task; } arg = { task };
00938     return rtai_lxrt(BIDX, SIZARG, RT_GET_ERRNO, &arg).i[LOW];
00939 }
00940 
00941 RTAI_PROTO(int,rt_set_linux_signal_handler,(RT_TASK *task, void (*handler)(int sig)))
00942 {
00943     struct { RT_TASK *task; void (*handler)(int sig); } arg = { task, handler };
00944     return rtai_lxrt(BIDX, SIZARG, RT_SET_LINUX_SIGNAL_HANDLER, &arg).i[LOW];
00945 }
00946 
00947 RTAI_PROTO(int, rt_lxrt_fork,(int is_a_clone))
00948 {
00949     struct { int is_a_clone; } arg = { is_a_clone };
00950     return rtai_lxrt(BIDX, SIZARG, LXRT_FORK, &arg).i[LOW];
00951 }
00952 
00953 RTAI_PROTO(int,rtai_print_to_screen,(const char *format, ...))
00954 {
00955         char display[256];
00956         struct { const char *display; int nch; } arg = { display, 0 };
00957         va_list args;
00958 
00959         va_start(args, format);
00960         arg.nch = vsprintf(display, format, args);
00961         va_end(args);
00962         rtai_lxrt(BIDX, SIZARG, PRINT_TO_SCREEN, &arg);
00963         return arg.nch;
00964 }
00965 
00966 RTAI_PROTO(int,rt_printk,(const char *format, ...))
00967 {
00968         char display[256];
00969         struct { const char *display; int nch; } arg = { display, 0 };
00970         va_list args;
00971 
00972         va_start(args, format);
00973         arg.nch = vsprintf(display, format, args);
00974         va_end(args);
00975         rtai_lxrt(BIDX, SIZARG, PRINTK, &arg);
00976         return arg.nch;
00977 }
00978 
00979 RTAI_PROTO(int,rt_usp_signal_handler,(void (*handler)(void)))
00980 {
00981         struct { void (*handler)(void); } arg = { handler };
00982         return rtai_lxrt(BIDX, SIZARG, USP_SIGHDL, &arg).i[0];
00983 }
00984 
00985 RTAI_PROTO(unsigned long,rt_get_usp_flags,(RT_TASK *rt_task))
00986 {
00987         struct { RT_TASK *task; } arg = { rt_task };
00988         return rtai_lxrt(BIDX, SIZARG, GET_USP_FLAGS, &arg).i[LOW];
00989 }
00990 
00991 RTAI_PROTO(unsigned long,rt_get_usp_flags_mask,(RT_TASK *rt_task))
00992 {
00993         struct { RT_TASK *task; } arg = { rt_task };
00994         return rtai_lxrt(BIDX, SIZARG, GET_USP_FLG_MSK, &arg).i[LOW];
00995 }
00996 
00997 RTAI_PROTO(void,rt_set_usp_flags,(RT_TASK *rt_task, unsigned long flags))
00998 {
00999         struct { RT_TASK *task; unsigned long flags; } arg = { rt_task, flags };
01000         rtai_lxrt(BIDX, SIZARG, SET_USP_FLAGS, &arg);
01001 }
01002 
01003 RTAI_PROTO(void,rt_set_usp_flags_mask,(unsigned long flags_mask))
01004 {
01005         struct { unsigned long flags_mask; } arg = { flags_mask };
01006         rtai_lxrt(BIDX, SIZARG, SET_USP_FLG_MSK, &arg);
01007 }
01008 
01009 RTAI_PROTO(RT_TASK *,rt_force_task_soft,(int pid))
01010 {
01011         struct { int pid; } arg = { pid };
01012         return (RT_TASK *)rtai_lxrt(BIDX, SIZARG, FORCE_TASK_SOFT, &arg).v[LOW];
01013 }
01014 
01015 RTAI_PROTO(RT_TASK *,rt_agent,(void))
01016 {
01017         struct { unsigned long dummy; } arg;
01018         return (RT_TASK *)rtai_lxrt(BIDX, SIZARG, RT_BUDDY, &arg).v[LOW];
01019 }
01020 
01021 #define rt_buddy() rt_agent()
01022 
01045 RTAI_PROTO(void,rt_make_hard_real_time,(void))
01046 {
01047         struct { unsigned long dummy; } arg;
01048         rtai_lxrt(BIDX, SIZARG, MAKE_HARD_RT, &arg);
01049 }
01050 
01059 RTAI_PROTO(void,rt_allow_nonroot_hrt,(void))
01060 {
01061         struct { unsigned long dummy; } arg;
01062         rtai_lxrt(BIDX, SIZARG, NONROOT_HRT, &arg);
01063 }
01064 
01065 RTAI_PROTO(int,rt_is_hard_real_time,(RT_TASK *rt_task))
01066 {
01067         struct { RT_TASK *task; } arg = { rt_task };
01068         return rtai_lxrt(BIDX, SIZARG, IS_HARD, &arg).i[LOW];
01069 }
01070 
01071 #define rt_is_soft_real_time(rt_task) (!rt_is_hard_real_time((rt_task)))
01072 
01073 RTAI_PROTO(void,rt_task_set_resume_end_times,(RTIME resume, RTIME end))
01074 {
01075         struct { RTIME resume, end; } arg = { resume, end };
01076         rtai_lxrt(BIDX, SIZARG, SET_RESUME_END, &arg);
01077 }
01078 
01079 RTAI_PROTO(int,rt_set_resume_time,(RT_TASK *rt_task, RTIME new_resume_time))
01080 {
01081         struct { RT_TASK *rt_task; RTIME new_resume_time; } arg = { rt_task, new_resume_time };
01082         return rtai_lxrt(BIDX, SIZARG, SET_RESUME_TIME, &arg).i[LOW];
01083 }
01084 
01085 RTAI_PROTO(int,rt_set_period,(RT_TASK *rt_task, RTIME new_period))
01086 {
01087         struct { RT_TASK *rt_task; RTIME new_period; } arg = { rt_task, new_period };
01088         return rtai_lxrt(BIDX, SIZARG, SET_PERIOD, &arg).i[LOW];
01089 }
01090 
01091 RTAI_PROTO(void,rt_spv_RMS,(int cpuid))
01092 {
01093         struct { int cpuid; } arg = { cpuid };
01094         rtai_lxrt(BIDX, SIZARG, SPV_RMS, &arg);
01095 }
01096 
01097 RTAI_PROTO(int,rt_task_wakeup_sleeping,(RT_TASK *task))
01098 {
01099         struct { RT_TASK *task; } arg = { task };
01100         return rtai_lxrt(BIDX, SIZARG, WAKEUP_SLEEPING, &arg).i[LOW];
01101 }
01102 
01103 RTAI_PROTO(void,rt_get_exectime,(RT_TASK *task, RTIME *exectime))
01104 {
01105         RTIME lexectime[] = { 0LL, 0LL, 0LL };
01106         struct { RT_TASK *task; RTIME *lexectime; } arg = { task, lexectime };
01107         rtai_lxrt(BIDX, SIZARG, GET_EXECTIME, &arg);
01108         memcpy(exectime, lexectime, sizeof(lexectime));
01109 }
01110 
01111 RTAI_PROTO(void,rt_gettimeorig,(RTIME time_orig[]))
01112 {
01113         struct { RTIME *time_orig; } arg = { time_orig };
01114         rtai_lxrt(BIDX, SIZARG, GET_TIMEORIG, &arg);
01115 }
01116 
01117 #ifdef __cplusplus
01118 }
01119 #endif /* __cplusplus */
01120 
01121 #endif /* __KERNEL__ */
01122 
01125 #endif /* !_RTAI_LXRT_H */

Generated on Sat Jul 24 19:36:02 2004 for RTAI API by doxygen 1.3.4