RTAI API: base/include/rtai_netrpc.h Source File

00001 /* 00002 * Copyright (C) 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it> 00003 * 00004 * This program is free software; you can redistribute it and/or 00005 * modify it under the terms of the GNU General Public License as 00006 * published by the Free Software Foundation; either version 2 of the 00007 * License, or (at your option) any later version. 00008 * 00009 * This program is distributed in the hope that it will be useful, 00010 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00012 * GNU General Public License for more details. 00013 * 00014 * You should have received a copy of the GNU General Public License 00015 * along with this program; if not, write to the Free Software 00016 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00017 */ 00018 00019 #ifndef _RTAI_NETRPC_H 00020 #define _RTAI_NETRPC_H 00021 00022 #include <rtai_config.h> 00023 00024 #ifdef CONFIG_RTAI_INTERNAL_LXRT_SUPPORT 00025 00026 #include <rtai_registry.h> 00027 #include <rtai_lxrt.h> 00028 #include <rtai_sem.h> 00029 #include <rtai_mbx.h> 00030 #include <rtai_msg.h> 00031 00032 #define MAX_STUBS 16 // _M_U_S_T___B_E___P_O_W_E_R___O_F___2_ 00033 #define MAX_SOCKS 16 00034 #define MAX_MSG_SIZE 1500 00035 00036 #define NET_RPC_EXT 0 00037 00038 // for writes 00039 #define UW1(bf, sz) ((((bf) & 0x7) << 19) | (((sz) & 0x7) << 22)) 00040 #define UW2(bf, sz) ((((bf) & 0x7) << 25) | (((sz) & 0x7) << 28)) 00041 00042 // for reads 00043 #define UR1(bf, sz) ((((bf) & 0x7) << 3) | (((sz) & 0x7) << 6)) 00044 #define UR2(bf, sz) ((((bf) & 0x7) << 9) | (((sz) & 0x7) << 12)) 00045 00046 #define SIZARG sizeof(arg) 00047 00048 #define PACKPORT(port, ext, fun, timed) (((port) << 18) | ((timed) << 13) | ((ext) << 8) | (fun)) 00049 00050 #define PORT(i) ((i) >> 18) 00051 #define FUN(i) ((i) & 0xFF) 00052 #define EXT(i) (((i) >> 8) & 0x1F) 00053 #define TIMED(i) (((i) >> 13) & 0x1F) 00054 00055 /* 00056 * SYNC_NET_RPC is hard wired here, no need to have it elsewhere. It must 00057 * have all the bits allowed to the "fun" field, in PACKPORT above, set. 00058 */ 00059 #define SYNC_NET_RPC 0xFF // hard wired here, no need to have it elsewhere 00060 00061 #define PRT_REQ 1 00062 #define PRT_SRV 2 00063 #define PRT_RTR 3 00064 #define PRT_RCV 4 00065 #define RPC_REQ 5 00066 #define RPC_SRV 6 00067 #define RPC_RTR 7 00068 #define RPC_RCV 8 00069 00070 #define OWNER(node, task) \ 00071 ((((unsigned long long)(node)) << 32) | (unsigned long)(task)) 00072 00073 #ifdef __KERNEL__ 00074 00075 #include <rtai_sched.h> 00076 00077 #ifdef __cplusplus 00078 extern "C" { 00079 #endif /* __cplusplus */ 00080 00081 int __rtai_netrpc_init(void); 00082 00083 void __rtai_netrpc_exit(void); 00084 00085 unsigned long long rt_net_rpc(long fun_ext_timed, 00086 long type, 00087 void *args, 00088 int argsize, 00089 int space); 00090 00091 int rt_send_req_rel_port(unsigned long node, 00092 int port, 00093 unsigned long id, 00094 MBX *mbx, 00095 int hard); 00096 00097 unsigned long ddn2nl(const char *ddn); 00098 00099 unsigned long rt_set_this_node(const char *ddn, 00100 unsigned long node, 00101 int hard); 00102 00103 RT_TASK *rt_find_asgn_stub(unsigned long long owner, 00104 int asgn); 00105 00106 int rt_rel_stub(unsigned long long owner); 00107 00108 int rt_waiting_return(unsigned long node, 00109 int port); 00110 00111 int rt_get_net_rpc_ret(MBX *mbx, 00112 unsigned long long *retval, 00113 void *msg1, 00114 int *msglen1, 00115 void *msg2, 00116 int *msglen2, 00117 RTIME timeout, 00118 int type); 00119 00120 static inline int rt_sync_net_rpc(unsigned long node, int port) 00121 { 00122 if (node) { 00123 struct { long dummy; } arg = { 0 }; 00124 return rt_net_rpc(PACKPORT(abs(port), NET_RPC_EXT, SYNC_NET_RPC, 0), 0, &arg, SIZARG, 1); 00125 } 00126 return 1; 00127 } 00128 00129 static inline void *RT_get_adr(unsigned long node, int port, const char *sname) 00130 { 00131 if (node) { 00132 struct { unsigned long name; } arg = { nam2num(sname) }; 00133 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, GET_ADR, 0), 0, &arg, SIZARG, 1); 00134 } 00135 return rt_get_adr(nam2num(sname)); 00136 } 00137 00138 static inline RT_TASK *RT_named_task_init(unsigned long node, int port, const char *task_name, void (*thread)(long), long data, int stack_size, int prio, int uses_fpu, void(*signal)(void)) 00139 { 00140 if (node) { 00141 struct { const char *task_name; void (*thread)(long); long data; long stack_size; long prio; long uses_fpu; void(*signal)(void); long namelen; } arg = { task_name, thread, data, stack_size, prio, uses_fpu, signal, strlen(task_name) }; 00142 return (RT_TASK *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_TASK_INIT, 0), UR1(1, 8), &arg, SIZARG, 1); 00143 } 00144 return rt_named_task_init(task_name, thread, data, stack_size, prio, uses_fpu, signal); 00145 } 00146 00147 static inline RT_TASK *RT_named_task_init_cpuid(unsigned long node, int port, const char *task_name, void (*thread)(long), long data, int stack_size, int prio, int uses_fpu, void(*signal)(void), unsigned int run_on_cpu) 00148 { 00149 if (node) { 00150 struct { const char *task_name; void (*thread)(long); long data; long stack_size; long prio; long uses_fpu; void(*signal)(void); unsigned int run_on_cpu; long namelen; } arg = { task_name, thread, data, stack_size, prio, uses_fpu, signal, run_on_cpu, strlen(task_name) }; 00151 return (RT_TASK *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_TASK_INIT_CPUID, 0), UR1(1, 9), &arg, SIZARG, 1); 00152 } 00153 return rt_named_task_init_cpuid(task_name, thread, data, stack_size, prio, uses_fpu, signal, run_on_cpu); 00154 } 00155 00156 static inline int RT_named_task_delete(unsigned long node, int port, RT_TASK *task) 00157 { 00158 if (node) { 00159 struct { RT_TASK *task; } arg = { task }; 00160 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_TASK_DELETE, 0), 0, &arg, SIZARG, 1); 00161 } 00162 return rt_named_task_delete(task); 00163 } 00164 00165 static inline RTIME RT_get_time_ns(unsigned long node, int port) 00166 { 00167 if (node) { 00168 struct { long dummy; } arg = { 0 }; 00169 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, GET_TIME_NS, 0), 0, &arg, SIZARG, 1); 00170 } 00171 return rt_get_time_ns(); 00172 } 00173 00174 static inline RTIME RT_get_time_ns_cpuid(unsigned long node, int port, int cpuid) 00175 { 00176 if (node) { 00177 struct { long cpuid; } arg = { cpuid }; 00178 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, GET_TIME_NS_CPUID, 0), 0, &arg, SIZARG, 1); 00179 } 00180 return rt_get_time_ns_cpuid(cpuid); 00181 } 00182 00183 static inline RTIME RT_get_cpu_time_ns(unsigned long node, int port) 00184 { 00185 if (node) { 00186 struct { long dummy; } arg = { 0 }; 00187 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, GET_CPU_TIME_NS, 0), 0, &arg, SIZARG, 1); 00188 } 00189 return rt_get_cpu_time_ns(); 00190 } 00191 00192 static inline int RT_task_suspend(unsigned long node, int port, RT_TASK *task) 00193 { 00194 if (node) { 00195 struct { RT_TASK *task; } arg = { task }; 00196 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SUSPEND, 0), 0, &arg, SIZARG, 1); 00197 } 00198 return rt_task_suspend(task); 00199 } 00200 00201 static inline int RT_task_resume(unsigned long node, int port, RT_TASK *task) 00202 { 00203 if (node) { 00204 struct { RT_TASK *task; } arg = { task }; 00205 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RESUME, 0), 0, &arg, SIZARG, 1); 00206 } 00207 return rt_task_resume(task); 00208 } 00209 00210 static inline void RT_sleep(unsigned long node, int port, RTIME delay) 00211 { 00212 if (node) { 00213 struct { RTIME delay; } arg = { delay }; 00214 rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SLEEP, 1), 0, &arg, SIZARG, 1); 00215 return; 00216 } 00217 rt_sleep(nano2count(delay)); 00218 } 00219 00220 static inline void RT_sleep_until(unsigned long node, int port, RTIME time) 00221 { 00222 if (node) { 00223 struct { RTIME time; } arg = { time }; 00224 rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SLEEP_UNTIL, 1), 0, &arg, SIZARG, 1); 00225 return; 00226 } 00227 rt_sleep_until(nano2count(time)); 00228 } 00229 00230 #if CONFIG_RTAI_SEM 00231 00232 static inline SEM *RT_typed_named_sem_init(unsigned long node, int port, const char *sem_name, int value, int type) 00233 { 00234 if (node) { 00235 struct { unsigned long sem_name; long value; long type; long namelen; } arg = { nam2num(sem_name), value, type }; 00236 return (SEM *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_SEM_INIT, 0), 0, &arg, SIZARG, 1); 00237 } 00238 return rt_typed_named_sem_init(sem_name, value, type); 00239 } 00240 00241 static inline int RT_named_sem_delete(unsigned long node, int port, SEM *sem) 00242 { 00243 if (node) { 00244 struct { SEM *sem; } arg = { sem }; 00245 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_SEM_DELETE, 0), 0, &arg, SIZARG, 1); 00246 } 00247 return rt_named_sem_delete(sem); 00248 } 00249 00250 static inline int RT_sem_signal(unsigned long node, int port, SEM *sem) 00251 { 00252 if (node) { 00253 struct { SEM *sem; } arg = { sem }; 00254 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_SIGNAL, 0), 0, &arg, SIZARG, 1); 00255 } 00256 return rt_sem_signal(sem); 00257 } 00258 00259 static inline int RT_sem_broadcast(unsigned long node, int port, SEM *sem) 00260 { 00261 if (node) { 00262 struct { SEM *sem; } arg = { sem }; 00263 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_BROADCAST, 0), 0, &arg, SIZARG, 1); 00264 } 00265 return rt_sem_broadcast(sem); 00266 } 00267 00268 static inline int RT_sem_wait(unsigned long node, int port, SEM *sem) 00269 { 00270 if (node) { 00271 struct { SEM *sem; } arg = { sem }; 00272 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_WAIT, 0), 0, &arg, SIZARG, 1); 00273 } 00274 return rt_sem_wait(sem); 00275 } 00276 00277 static inline int RT_sem_wait_if(unsigned long node, int port, SEM *sem) 00278 { 00279 if (node) { 00280 struct { SEM *sem; } arg = { sem }; 00281 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_WAIT_IF, 0), 0, &arg, SIZARG, 1); 00282 } 00283 return rt_sem_wait_if(sem); 00284 } 00285 00286 static inline int RT_sem_wait_until(unsigned long node, int port, SEM *sem, RTIME time) 00287 { 00288 if (node) { 00289 struct { SEM *sem; RTIME time; } arg = { sem, time }; 00290 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_WAIT_UNTIL, 2), 0, &arg, SIZARG, 1); 00291 } 00292 return rt_sem_wait_until(sem, nano2count(time)); 00293 } 00294 00295 static inline int RT_sem_wait_timed(unsigned long node, int port, SEM *sem, RTIME delay) 00296 { 00297 if (node) { 00298 struct { SEM *sem; RTIME delay; } arg = { sem, delay }; 00299 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEM_WAIT_TIMED, 2), 0, &arg, SIZARG, 1); 00300 } 00301 return rt_sem_wait_timed(sem, nano2count(delay)); 00302 } 00303 00304 #endif /* CONFIG_RTAI_SEM */ 00305 00306 #if CONFIG_RTAI_MSG 00307 00308 static inline RT_TASK *RT_send(unsigned long node, int port, RT_TASK *task, unsigned long msg) 00309 { 00310 if (node) { 00311 struct { RT_TASK *task; unsigned long msg; } arg = { task, msg }; 00312 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SENDMSG, 0), 0, &arg, SIZARG, 1); 00313 } 00314 return rt_send(task, msg); 00315 } 00316 00317 static inline RT_TASK *RT_send_if(unsigned long node, int port, RT_TASK *task, unsigned long msg) 00318 { 00319 if (node) { 00320 struct { RT_TASK *task; unsigned long msg; } arg = { task, msg }; 00321 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEND_IF, 0), 0, &arg, SIZARG, 1); 00322 } 00323 return rt_send_if(task, msg); 00324 } 00325 00326 static inline RT_TASK *RT_send_until(unsigned long node, int port, RT_TASK *task, unsigned long msg, RTIME time) 00327 { 00328 if (node) { 00329 struct { RT_TASK *task; unsigned long msg; RTIME time; } arg = { task, msg, time }; 00330 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEND_UNTIL, 3), 0, &arg, SIZARG, 1); 00331 } 00332 return rt_send_until(task, msg, nano2count(time)); 00333 } 00334 00335 static inline RT_TASK *RT_send_timed(unsigned long node, int port, RT_TASK *task, unsigned long msg, RTIME delay) 00336 { 00337 if (node) { 00338 struct { RT_TASK *task; unsigned long msg; RTIME delay; } arg = { task, msg, delay }; 00339 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SEND_TIMED, 3), 0, &arg, SIZARG, 1); 00340 } 00341 return rt_send_timed(task, msg, nano2count(delay)); 00342 } 00343 00344 static inline RT_TASK *RT_receive(unsigned long node, int port, RT_TASK *task, unsigned long *msg) 00345 { 00346 if (!task || !node) { 00347 return rt_receive(task, msg); 00348 } 00349 return rt_receive(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00350 } 00351 00352 static inline RT_TASK *RT_receive_if(unsigned long node, int port, RT_TASK *task, unsigned long *msg) 00353 { 00354 if (!task || !node) { 00355 return rt_receive_if(task, msg); 00356 } 00357 return rt_receive_if(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00358 } 00359 00360 static inline RT_TASK *RT_receive_until(unsigned long node, int port, RT_TASK *task, unsigned long *msg, RTIME time) 00361 { 00362 if (!task || !node) { 00363 return rt_receive_until(task, msg, nano2count(time)); 00364 } 00365 return rt_receive_until(rt_find_asgn_stub(OWNER(node, task), 1), msg, nano2count(time)) ? task : 0; 00366 } 00367 00368 static inline RT_TASK *RT_receive_timed(unsigned long node, int port, RT_TASK *task, unsigned long *msg, RTIME delay) 00369 { 00370 if (!task || !node) { 00371 return rt_receive_timed(task, msg, nano2count(delay)); 00372 } 00373 return rt_receive_timed(rt_find_asgn_stub(OWNER(node, task), 1), msg, nano2count(delay)) ? task : 0; 00374 } 00375 00376 static inline RT_TASK *RT_rpc(unsigned long node, int port, RT_TASK *task, unsigned long msg, unsigned long *ret) 00377 { 00378 if (node) { 00379 struct { RT_TASK *task; unsigned long msg; unsigned long *ret; } arg = { task, msg, ret }; 00380 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPCMSG, 0), UW1(3, 0), &arg, SIZARG, 1); 00381 } 00382 return rt_rpc(task, msg, ret); 00383 } 00384 00385 static inline RT_TASK *RT_rpc_if(unsigned long node, int port, RT_TASK *task, unsigned long msg, unsigned long *ret) 00386 { 00387 if (node) { 00388 struct { RT_TASK *task; unsigned long msg; unsigned long *ret; } arg = { task, msg }; 00389 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPC_IF, 0), UW1(3, 0), &arg, SIZARG, 1); 00390 } 00391 return rt_rpc_if(task, msg, ret); 00392 } 00393 00394 static inline RT_TASK *RT_rpc_until(unsigned long node, int port, RT_TASK *task, unsigned long msg, unsigned long *ret, RTIME time) 00395 { 00396 if (node) { 00397 struct { RT_TASK *task; unsigned long msg; unsigned long *ret; RTIME time; } arg = { task, msg, ret, time }; 00398 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPC_UNTIL, 4), UW1(3, 0), &arg, SIZARG, 1); 00399 } 00400 return rt_rpc_until(task, msg, ret, nano2count(time)); 00401 } 00402 00403 static inline RT_TASK *RT_rpc_timed(unsigned long node, int port, RT_TASK *task, unsigned long msg, unsigned long *ret, RTIME delay) 00404 { 00405 if (node) { 00406 struct { RT_TASK *task; unsigned long msg; unsigned long *ret; RTIME delay; } arg = { task, msg, ret, delay }; 00407 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPC_TIMED, 4), UW1(3, 0), &arg, SIZARG, 1); 00408 } 00409 return rt_rpc_timed(task, msg, ret, nano2count(delay)); 00410 } 00411 00412 static inline int RT_isrpc(unsigned long node, int port, RT_TASK *task) 00413 { 00414 if (node) { 00415 struct { RT_TASK *task; } arg = { task }; 00416 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, ISRPC, 0), 0, &arg, SIZARG, 1); 00417 } 00418 return rt_isrpc(task); 00419 } 00420 00421 static inline RT_TASK *RT_return(unsigned long node, int port, RT_TASK *task, unsigned long result) 00422 { 00423 if (!task || !node) { 00424 return rt_return(task, result); 00425 } 00426 return rt_return(rt_find_asgn_stub(OWNER(node, task), 1), result) ? task : 0; 00427 } 00428 00429 static inline RT_TASK *RT_evdrp(unsigned long node, int port, RT_TASK *task, unsigned long *msg) 00430 { 00431 if (!task || !node) { 00432 return rt_evdrp(task, msg); 00433 } 00434 return rt_evdrp(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00435 } 00436 00437 static inline RT_TASK *RT_rpcx(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize) 00438 { 00439 if (node) { 00440 struct { RT_TASK *task; void *smsg; void *rmsg; long ssize; long rsize; } arg = { task, smsg, rmsg, ssize, rsize }; 00441 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPCX, 0), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 1); 00442 } 00443 return rt_rpcx(task, smsg, rmsg, ssize, rsize); 00444 } 00445 00446 static inline RT_TASK *RT_rpcx_if(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize) 00447 { 00448 if (node) { 00449 struct { RT_TASK *task; void *smsg; void *rmsg; long ssize; long rsize; } arg = { task, smsg, rmsg, ssize, rsize }; 00450 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPCX_IF, 0), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 1); 00451 } 00452 return rt_rpcx_if(task, smsg, rmsg, ssize, rsize); 00453 } 00454 00455 static inline RT_TASK *RT_rpcx_until(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME time) 00456 { 00457 if (node) { 00458 struct { RT_TASK *task; void *smsg; void *rmsg; long ssize; long rsize; RTIME time; } arg = { task, smsg, rmsg, ssize, rsize, time }; 00459 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPCX_UNTIL, 6), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 1); 00460 } 00461 return rt_rpcx_until(task, smsg, rmsg, ssize, rsize, nano2count(time)); 00462 } 00463 00464 static inline RT_TASK *RT_rpcx_timed(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME delay) 00465 { 00466 if (node) { 00467 struct { RT_TASK *task; void *smsg; void *rmsg; long ssize; long rsize; RTIME delay; } arg = { task, smsg, rmsg, ssize, rsize, delay }; 00468 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, RPCX_TIMED, 6), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 1); 00469 } 00470 return rt_rpcx_timed(task, smsg, rmsg, ssize, rsize, nano2count(delay)); 00471 } 00472 00473 static inline RT_TASK *RT_sendx(unsigned long node, int port, RT_TASK *task, void *msg, int size) 00474 { 00475 if (node) { 00476 struct { RT_TASK *task; void *msg; long size; } arg = { task, msg, size }; 00477 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SENDX, 0), UR1(2, 3), &arg, SIZARG, 1); 00478 } 00479 return rt_sendx(task, msg, size); 00480 } 00481 00482 static inline RT_TASK *RT_sendx_if(unsigned long node, int port, RT_TASK *task, void *msg, int size) 00483 { 00484 if (node) { 00485 struct { RT_TASK *task; void *msg; long size; } arg = { task, msg, size }; 00486 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SENDX_IF, 0), UR1(2, 3), &arg, SIZARG, 1); 00487 } 00488 return rt_sendx_if(task, msg, size); 00489 } 00490 00491 static inline RT_TASK *RT_sendx_until(unsigned long node, int port, RT_TASK *task, void *msg, int size, RTIME time) 00492 { 00493 if (node) { 00494 struct { RT_TASK *task; void *msg; long size; RTIME time; } arg = { task, msg, size, time }; 00495 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SENDX_UNTIL, 4), UR1(2, 3), &arg, SIZARG, 1); 00496 } 00497 return rt_sendx_until(task, msg, size, nano2count(time)); 00498 } 00499 00500 static inline RT_TASK *RT_sendx_timed(unsigned long node, int port, RT_TASK *task, void *msg, int size, RTIME delay) 00501 { 00502 if (node) { 00503 struct { RT_TASK *task; void *msg; long size; RTIME delay; } arg = { task, msg, size, delay }; 00504 return (void *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, SENDX_TIMED, 4), UR1(2, 3), &arg, SIZARG, 1); 00505 } 00506 return rt_sendx_timed(task, msg, size, nano2count(delay)); 00507 } 00508 00509 static inline RT_TASK *RT_returnx(unsigned long node, int port, RT_TASK *task, void *msg, int size) 00510 { 00511 if (!task || !node) { 00512 return rt_returnx(task, msg, size); 00513 } 00514 return rt_returnx(rt_find_asgn_stub(OWNER(node, task), 1), msg, size) ? task : 0; 00515 } 00516 00517 static inline RT_TASK *RT_evdrpx(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 00518 { 00519 if (!task || !node) { 00520 return rt_evdrpx(task, msg, size, len); 00521 } 00522 return rt_evdrpx(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 00523 } 00524 00525 static inline RT_TASK *RT_receivex(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 00526 { 00527 if (!task || !node) { 00528 return rt_receivex(task, msg, size, len); 00529 } 00530 return rt_receivex(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 00531 } 00532 00533 static inline RT_TASK *RT_receivex_if(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 00534 { 00535 if (!task || !node) { 00536 return rt_receivex_if(task, msg, size, len); 00537 } 00538 return rt_receivex_if(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 00539 } 00540 00541 static inline RT_TASK *RT_receivex_until(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len, RTIME time) 00542 { 00543 if (!task || !node) { 00544 return rt_receivex_until(task, msg, size, len, nano2count(time)); 00545 } 00546 return rt_receivex_until(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len, nano2count(time)) ? task : 0; 00547 } 00548 00549 static inline RT_TASK *RT_receivex_timed(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len, RTIME delay) 00550 { 00551 if (!task || !node) { 00552 return rt_receivex_timed(task, msg, size, len, nano2count(delay)); 00553 } 00554 return rt_receivex_timed(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len, nano2count(delay)) ? task : 0; 00555 } 00556 00557 #endif /* CONFIG_RTAI_MSG */ 00558 00559 #if CONFIG_RTAI_MBX 00560 00561 static inline MBX *RT_typed_named_mbx_init(unsigned long node, int port, const char *mbx_name, int size, int qtype) 00562 { 00563 if (node) { 00564 struct { unsigned long mbx_name; long size; long qype; long namelen; } arg = { nam2num(mbx_name), size, qtype }; 00565 return (MBX *)(unsigned long)rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_MBX_INIT, 0), 0, &arg, SIZARG, 1); 00566 } 00567 return rt_typed_named_mbx_init(mbx_name, size, qtype); 00568 } 00569 00570 static inline int RT_named_mbx_delete(unsigned long node, int port, MBX *mbx) 00571 { 00572 if (node) { 00573 struct { MBX *mbx; } arg = { mbx }; 00574 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, NAMED_MBX_DELETE, 0), 0, &arg, SIZARG, 1); 00575 } 00576 return rt_named_mbx_delete(mbx); 00577 } 00578 00579 static inline int RT_mbx_send(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00580 { 00581 if (node) { 00582 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00583 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_SEND, 0), UR1(2, 3), &arg, SIZARG, 1); 00584 } 00585 return rt_mbx_send(mbx, msg, msg_size); 00586 } 00587 00588 static inline int RT_mbx_send_wp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00589 { 00590 if (node) { 00591 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00592 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_SEND_WP, 0), UR1(2, 3), &arg, SIZARG, 1); 00593 } 00594 return rt_mbx_send_wp(mbx, msg, msg_size); 00595 } 00596 00597 static inline int RT_mbx_send_if(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00598 { 00599 if (node) { 00600 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00601 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_SEND_IF, 0), UR1(2, 3), &arg, SIZARG, 1); 00602 } 00603 return rt_mbx_send_if(mbx, msg, msg_size); 00604 } 00605 00606 static inline int RT_mbx_ovrwr_send(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00607 { 00608 if (node) { 00609 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00610 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_OVRWR_SEND, 0), UR1(2, 3), &arg, SIZARG, 1); 00611 } 00612 return rt_mbx_ovrwr_send(mbx, msg, msg_size); 00613 } 00614 00615 static inline int RT_mbx_send_until(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME time) 00616 { 00617 if (node) { 00618 struct { MBX *mbx; void *msg; long msg_size; RTIME time; long space; } arg = { mbx, msg, msg_size, time, 1 }; 00619 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_SEND_UNTIL, 4), UR1(2, 3), &arg, SIZARG, 1); 00620 } 00621 return rt_mbx_send_until(mbx, msg, msg_size, nano2count(time)); 00622 } 00623 00624 static inline int RT_mbx_send_timed(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME delay) 00625 { 00626 if (node) { 00627 struct { MBX *mbx; void *msg; long msg_size; RTIME delay; long space; } arg = { mbx, msg, msg_size, delay, 1 }; 00628 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_SEND_TIMED, 4), UR1(2, 3), &arg, SIZARG, 1); 00629 } 00630 return rt_mbx_send_timed(mbx, msg, msg_size, nano2count(delay)); 00631 } 00632 00633 static inline int RT_mbx_evdrp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00634 { 00635 if (node) { 00636 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00637 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_EVDRP, 0), UW1(2, 3), &arg, SIZARG, 1); 00638 } 00639 return rt_mbx_evdrp(mbx, msg, msg_size); 00640 } 00641 00642 static inline int RT_mbx_receive(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00643 { 00644 if (node) { 00645 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00646 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE, 0), UW1(2, 3), &arg, SIZARG, 1); 00647 } 00648 return rt_mbx_receive(mbx, msg, msg_size); 00649 } 00650 00651 static inline int RT_mbx_receive_wp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00652 { 00653 if (node) { 00654 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00655 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_WP, 0), UW1(2, 3), &arg, SIZARG, 1); 00656 } 00657 return rt_mbx_receive_wp(mbx, msg, msg_size); 00658 } 00659 00660 static inline int RT_mbx_receive_if(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 00661 { 00662 if (node) { 00663 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 00664 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_IF, 0), UW1(2, 3), &arg, SIZARG, 1); 00665 } 00666 return rt_mbx_receive_if(mbx, msg, msg_size); 00667 } 00668 00669 static inline int RT_mbx_receive_until(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME time) 00670 { 00671 if (node) { 00672 struct { MBX *mbx; void *msg; long msg_size; RTIME time; long space; } arg = { mbx, msg, msg_size, time, 1 }; 00673 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_UNTIL, 4), UW1(2, 3), &arg, SIZARG, 1); 00674 } 00675 return rt_mbx_receive_until(mbx, msg, msg_size, nano2count(time)); 00676 } 00677 00678 static inline int RT_mbx_receive_timed(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME delay) 00679 { 00680 if (node) { 00681 struct { MBX *mbx; void *msg; long msg_size; RTIME delay; long space; } arg = { mbx, msg, msg_size, delay, 1 }; 00682 return rt_net_rpc(PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_TIMED, 4), UW1(2, 3), &arg, SIZARG, 1); 00683 } 00684 return rt_mbx_receive_timed(mbx, msg, msg_size, nano2count(delay)); 00685 } 00686 00687 #endif /* CONFIG_RTAI_MBX */ 00688 00689 #ifdef __cplusplus 00690 } 00691 #endif /* __cplusplus */ 00692 00693 #else /* !__KERNEL__ */ 00694 00695 #include <stdlib.h> 00696 00697 #define NET_RPC_IDX 0 00698 00699 #define SIZARGS sizeof(args) 00700 00701 static inline int rt_send_req_rel_port(unsigned long node, int port, unsigned long id, MBX *mbx, int hard) 00702 { 00703 struct { unsigned long node, port; unsigned long id; MBX *mbx; long hard; } args = { node, port, id, mbx, hard }; 00704 return rtai_lxrt(NET_RPC_IDX, SIZARGS, SEND_REQ_REL_PORT, &args).i[LOW]; 00705 } 00706 00707 static inline unsigned long ddn2nl(const char *ddn) 00708 { 00709 struct { const char *ddn; } args = { ddn }; 00710 return rtai_lxrt(NET_RPC_IDX, SIZARGS, DDN2NL, &args).i[LOW]; 00711 } 00712 00713 static inline unsigned long rt_set_this_node(const char *ddn, unsigned long node, int hard) 00714 { 00715 struct { const char *ddn; unsigned long node; long hard; } args = { ddn, node, hard }; 00716 return rtai_lxrt(NET_RPC_IDX, SIZARGS, SET_THIS_NODE, &args).i[LOW]; 00717 } 00718 00719 static inline RT_TASK *rt_find_asgn_stub(unsigned long long owner, int asgn) 00720 { 00721 struct { unsigned long long owner; long asgn; } args = { owner, asgn }; 00722 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, FIND_ASGN_STUB, &args).v[LOW]; 00723 } 00724 00725 static inline int rt_rel_stub(unsigned long long owner) 00726 { 00727 struct { unsigned long long owner; } args = { owner }; 00728 return rtai_lxrt(NET_RPC_IDX, SIZARGS, REL_STUB, &args).i[LOW]; 00729 } 00730 00731 static inline int rt_waiting_return(unsigned long node, int port) 00732 { 00733 struct { unsigned long node; long port; } args = { node, port }; 00734 return rtai_lxrt(NET_RPC_IDX, SIZARGS, WAITING_RETURN, &args).i[LOW]; 00735 } 00736 00737 static inline int rt_sync_net_rpc(unsigned long node, int port) 00738 { 00739 if (node) { 00740 struct { long dummy; } arg = { 0 }; 00741 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(abs(port), NET_RPC_EXT, SYNC_NET_RPC, 0), 0, &arg, SIZARG, 0 }; 00742 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00743 } 00744 return 1; 00745 } 00746 00747 static inline void *RT_get_adr(unsigned long node, int port, const char *sname) 00748 { 00749 if (node) { 00750 struct { unsigned long name; } arg = { nam2num(sname) }; 00751 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, GET_ADR, 0), 0, &arg,SIZARG, 0 }; 00752 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00753 } 00754 return rt_get_adr(nam2num(sname)); 00755 } 00756 00757 static inline RTIME RT_get_time_ns(unsigned long node, int port) 00758 { 00759 if (node) { 00760 struct { long dummy; } arg = { 0 }; 00761 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, GET_TIME_NS, 0), 0, &arg, SIZARG, 0 }; 00762 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).rt; 00763 } 00764 return rt_get_time_ns(); 00765 } 00766 00767 static inline RTIME RT_get_time_ns_cpuid(unsigned long node, int port, int cpuid) 00768 { 00769 if (node) { 00770 struct { long cpuid; } arg = { cpuid }; 00771 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, GET_TIME_NS_CPUID, 0), 0, &arg, SIZARG, 0 }; 00772 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).rt; 00773 } 00774 return rt_get_time_ns_cpuid(cpuid); 00775 } 00776 00777 static inline RTIME RT_get_cpu_time_ns(unsigned long node, int port) 00778 { 00779 if (node) { 00780 struct { long dummy; } arg = { 0 }; 00781 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, GET_CPU_TIME_NS, 0), 0, &arg, SIZARG, 0 }; 00782 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).rt; 00783 } 00784 return rt_get_cpu_time_ns(); 00785 } 00786 00787 static inline void RT_task_suspend(unsigned long node, int port, RT_TASK *task) 00788 { 00789 if (node) { 00790 struct { RT_TASK *task; } arg = { task }; 00791 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SUSPEND, 0), 0, &arg, SIZARG, 0 }; 00792 rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args); 00793 return; 00794 } 00795 rt_task_suspend(task); 00796 } 00797 00798 static inline void RT_task_resume(unsigned long node, int port, RT_TASK *task) 00799 { 00800 if (node) { 00801 struct { RT_TASK *task; } arg = { task }; 00802 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RESUME, 0), 0, &arg, SIZARG, 0 }; 00803 rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args); 00804 return; 00805 } 00806 rt_task_resume(task); 00807 } 00808 00809 static inline void RT_sleep(unsigned long node, int port, RTIME delay) 00810 { 00811 if (node) { 00812 struct { RTIME delay; } arg = { delay }; 00813 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SLEEP, 1), 0, &arg, SIZARG, 0 }; 00814 rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args); 00815 return; 00816 } 00817 rt_sleep(nano2count(delay)); 00818 } 00819 00820 static inline void RT_sleep_until(unsigned long node, int port, RTIME time) 00821 { 00822 if (node) { 00823 struct { RTIME time; } arg = { time }; 00824 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SLEEP_UNTIL, 1), 0, &arg, SIZARG, 0 }; 00825 rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args); 00826 return; 00827 } 00828 rt_sleep(nano2count(time)); 00829 } 00830 00831 #if CONFIG_RTAI_SEM 00832 00833 static inline SEM *RT_typed_named_sem_init(unsigned long node, int port, const char *sem_name, int value, int type) 00834 { 00835 if (node) { 00836 struct { unsigned long sem_name; long value; long type; long namelen; } arg = { nam2num(sem_name), value, type }; 00837 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, NAMED_SEM_INIT, 0), 0, &arg, SIZARG, 0 }; 00838 return (SEM *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00839 } 00840 return rt_typed_named_sem_init(sem_name, value, type); 00841 } 00842 00843 static inline int RT_named_sem_delete(unsigned long node, int port, SEM *sem) 00844 { 00845 if (node) { 00846 struct { SEM *sem; } arg = { sem }; 00847 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, NAMED_SEM_DELETE, 0), 0, &arg, SIZARG, 0 }; 00848 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00849 } 00850 return rt_named_sem_delete(sem); 00851 } 00852 00853 static inline int RT_sem_signal(unsigned long node, int port, SEM *sem) 00854 { 00855 if (node) { 00856 struct { SEM *sem; } arg = { sem }; 00857 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_SIGNAL, 0), 0, &arg, SIZARG, 0 }; 00858 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00859 } 00860 return rt_sem_signal(sem); 00861 } 00862 00863 static inline int RT_sem_broadcast(unsigned long node, int port, SEM *sem) 00864 { 00865 if (node) { 00866 struct { SEM *sem; } arg = { sem }; 00867 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_BROADCAST, 0), 0, &arg, SIZARG, 0 }; 00868 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00869 } 00870 return rt_sem_broadcast(sem); 00871 } 00872 00873 static inline int RT_sem_wait(unsigned long node, int port, SEM *sem) 00874 { 00875 if (node) { 00876 struct { SEM *sem; } arg = { sem }; 00877 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_WAIT, 0), 0, &arg, SIZARG, 0 }; 00878 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00879 } 00880 return rt_sem_wait(sem); 00881 } 00882 00883 static inline int RT_sem_wait_if(unsigned long node, int port, SEM *sem) 00884 { 00885 if (node) { 00886 struct { SEM *sem; } arg = { sem }; 00887 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_WAIT_IF, 0), 0, &arg, SIZARG, 0 }; 00888 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00889 } 00890 return rt_sem_wait_if(sem); 00891 } 00892 00893 static inline int RT_sem_wait_until(unsigned long node, int port, SEM *sem, RTIME time) 00894 { 00895 if (node) { 00896 struct { SEM *sem; RTIME time; } arg = { sem, time }; 00897 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_WAIT_UNTIL, 2), 0, &arg, SIZARG, 0 }; 00898 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00899 } 00900 return rt_sem_wait_until(sem, nano2count(time)); 00901 } 00902 00903 static inline int RT_sem_wait_timed(unsigned long node, int port, SEM *sem, RTIME delay) 00904 { 00905 if (node) { 00906 struct { SEM *sem; RTIME delay; } arg = { sem, delay }; 00907 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEM_WAIT_TIMED, 2), 0, &arg, SIZARG, 0 }; 00908 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 00909 } 00910 return rt_sem_wait_timed(sem, nano2count(delay)); 00911 } 00912 00913 #endif /* CONFIG_RTAI_SEM */ 00914 00915 #if CONFIG_RTAI_MSG 00916 00917 static inline RT_TASK *RT_send(unsigned long node, int port, RT_TASK *task, unsigned long msg) 00918 { 00919 if (node) { 00920 struct { RT_TASK *task; unsigned long msg; } arg = { task, msg }; 00921 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SENDMSG, 0), 0, &arg, SIZARG, 0 }; 00922 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00923 } 00924 return rt_send(task, msg); 00925 } 00926 00927 static inline RT_TASK *RT_send_if(unsigned long node, int port, RT_TASK *task, unsigned long msg) 00928 { 00929 if (node) { 00930 struct { RT_TASK *task; unsigned long msg; } arg = { task, msg }; 00931 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEND_IF, 0), 0, &arg, SIZARG, 0 }; 00932 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00933 } 00934 return rt_send_if(task, msg); 00935 } 00936 00937 static inline RT_TASK *RT_send_until(unsigned long node, int port, RT_TASK *task, unsigned long msg, RTIME time) 00938 { 00939 if (node) { 00940 struct { RT_TASK *task; unsigned long msg; RTIME time; } arg = { task, msg, time }; 00941 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEND_UNTIL, 3), 0, &arg, SIZARG, 0 }; 00942 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00943 } 00944 return rt_send_until(task, msg, nano2count(time)); 00945 } 00946 00947 static inline RT_TASK *RT_send_timed(unsigned long node, int port, RT_TASK *task, unsigned long msg, RTIME delay) 00948 { 00949 if (node) { 00950 struct { RT_TASK *task; unsigned long msg; RTIME delay; } arg = { task, msg, delay }; 00951 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SEND_TIMED, 3), 0, &arg, SIZARG, 0 }; 00952 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 00953 } 00954 return rt_send_timed(task, msg, nano2count(delay)); 00955 } 00956 00957 static inline RT_TASK *RT_evdrp(unsigned long node, int port, RT_TASK *task, void *msg) 00958 { 00959 if (!task || !node) { 00960 return rt_evdrp(task, msg); 00961 } 00962 return rt_evdrp(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00963 } 00964 00965 static inline RT_TASK *RT_receive(unsigned long node, int port, RT_TASK *task, void *msg) 00966 { 00967 if (!task || !node) { 00968 return rt_receive(task, msg); 00969 } 00970 return rt_receive(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00971 } 00972 00973 static inline RT_TASK *RT_receive_if(unsigned long node, int port, RT_TASK *task, void *msg) 00974 { 00975 if (!task || !node) { 00976 return rt_receive_if(task, msg); 00977 } 00978 return rt_receive_if(rt_find_asgn_stub(OWNER(node, task), 1), msg) ? task : 0; 00979 } 00980 00981 static inline RT_TASK *RT_receive_until(unsigned long node, int port, RT_TASK *task, void *msg, RTIME time) 00982 { 00983 if (!task || !node) { 00984 return rt_receive_until(task, msg, nano2count(time)); 00985 } 00986 return rt_receive_until(rt_find_asgn_stub(OWNER(node, task), 1), msg, nano2count(time)) ? task : 0; 00987 } 00988 00989 static inline RT_TASK *RT_receive_timed(unsigned long node, int port, RT_TASK *task, void *msg, RTIME delay) 00990 { 00991 if (!task || !node) { 00992 return rt_receive_timed(task, msg, nano2count(delay)); 00993 } 00994 return rt_receive_timed(rt_find_asgn_stub(OWNER(node, task), 1), msg, nano2count(delay)) ? task : 0; 00995 } 00996 00997 static inline RT_TASK *RT_rpc(unsigned long node, int port, RT_TASK *task, unsigned long msg, void *ret) 00998 { 00999 if (node) { 01000 struct { RT_TASK *task; unsigned long msg; void *ret; } arg = { task, msg, ret }; 01001 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPCMSG, 0), UW1(3, 0), &arg, SIZARG, 0 }; 01002 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01003 } 01004 return rt_rpc(task, msg, ret); 01005 } 01006 01007 static inline RT_TASK *RT_rpc_if(unsigned long node, int port, RT_TASK *task, unsigned long msg, void *ret) 01008 { 01009 if (node) { 01010 struct { RT_TASK *task; unsigned long msg; void *ret; } arg = { task, msg, ret }; 01011 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPC_IF, 0), UW1(3, 0), &arg, SIZARG, 0 }; 01012 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01013 } 01014 return rt_rpc_if(task, msg, ret); 01015 } 01016 01017 static inline RT_TASK *RT_rpc_until(unsigned long node, int port, RT_TASK *task, unsigned long msg, void *ret, RTIME time) 01018 { 01019 if (node) { 01020 struct { RT_TASK *task; unsigned long msg; void *ret; RTIME time; } arg = { task, msg, ret, time }; 01021 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPC_UNTIL, 4), UW1(3, 0), &arg, SIZARG, 0 }; 01022 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01023 } 01024 return rt_rpc_until(task, msg, ret, nano2count(time)); 01025 } 01026 01027 static inline RT_TASK *RT_rpc_timed(unsigned long node, int port, RT_TASK *task, unsigned long msg, void *ret, RTIME delay) 01028 { 01029 if (node) { 01030 struct { RT_TASK *task; unsigned long msg; void *ret; RTIME delay; } arg = { task, msg, ret, delay }; 01031 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPC_TIMED, 4), UW1(3, 0), &arg, SIZARG, 0 }; 01032 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01033 } 01034 return rt_rpc_timed(task, msg, ret, nano2count(delay)); 01035 } 01036 01037 static inline int RT_isrpc(unsigned long node, int port, RT_TASK *task) 01038 { 01039 if (node) { 01040 struct { RT_TASK *task; } arg = { task }; 01041 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, ISRPC, 0), 0, &arg, SIZARG, 0 }; 01042 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01043 } 01044 return rt_isrpc(task); 01045 } 01046 01047 static inline RT_TASK *RT_return(unsigned long node, int port, RT_TASK *task, unsigned long result) 01048 { 01049 01050 if (!task || !node) { 01051 return rt_return(task, result); 01052 } 01053 return rt_return(rt_find_asgn_stub(OWNER(node, task), 1), result) ? task : 0; 01054 } 01055 01056 static inline RT_TASK *RT_rpcx(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize) 01057 { 01058 if (node) { 01059 struct { RT_TASK *task; void *smsg, *rmsg; long ssize, rsize; } arg = { task, smsg, rmsg, ssize, rsize }; 01060 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPCX, 0), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 0 }; 01061 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01062 } 01063 return rt_rpcx(task, smsg, rmsg, ssize, rsize); 01064 } 01065 01066 static inline RT_TASK *RT_rpcx_if(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize) 01067 { 01068 if (node) { 01069 struct { RT_TASK *task; void *smsg, *rmsg; long ssize, rsize; } arg = { task, smsg, rmsg, ssize, rsize }; 01070 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPCX_IF, 0), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 0 }; 01071 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01072 } 01073 return rt_rpcx_if(task, smsg, rmsg, ssize, rsize); 01074 } 01075 01076 static inline RT_TASK *RT_rpcx_until(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME time) 01077 { 01078 if (node) { 01079 struct { RT_TASK *task; void *smsg, *rmsg; long ssize, rsize; RTIME time; } arg = { task, smsg, rmsg, ssize, rsize, time }; 01080 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPCX_UNTIL, 6), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 0 }; 01081 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01082 } 01083 return rt_rpcx_until(task, smsg, rmsg, ssize, rsize, nano2count(time)); 01084 } 01085 01086 static inline RT_TASK *RT_rpcx_timed(unsigned long node, int port, RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME delay) 01087 { 01088 if (node) { 01089 struct { RT_TASK *task; void *smsg, *rmsg; long ssize, rsize; RTIME delay; } arg = { task, smsg, rmsg, ssize, rsize, delay }; 01090 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, RPCX_TIMED, 6), UR1(2, 4) | UW1(3, 5), &arg, SIZARG, 0 }; 01091 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01092 } 01093 return rt_rpcx_timed(task, smsg, rmsg, ssize, rsize, nano2count(delay)); 01094 } 01095 01096 static inline RT_TASK *RT_sendx(unsigned long node, int port, RT_TASK *task, void *msg, int size) 01097 { 01098 if (node) { 01099 struct { RT_TASK *task; void *msg; long size; } arg = { task, msg, size }; 01100 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SENDX, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01101 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01102 } 01103 return rt_sendx(task, msg, size); 01104 } 01105 01106 static inline RT_TASK *RT_sendx_if(unsigned long node, int port, RT_TASK *task, void *msg, int size) 01107 { 01108 if (node) { 01109 struct { RT_TASK *task; void *msg; long size; } arg = { task, msg, size }; 01110 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SENDX_IF, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01111 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01112 } 01113 return rt_sendx_if(task, msg, size); 01114 } 01115 01116 static inline RT_TASK *RT_sendx_until(unsigned long node, int port, RT_TASK *task, void *msg, int size, RTIME time) 01117 { 01118 if (node) { 01119 struct { RT_TASK *task; void *msg; long size; RTIME time; } arg = { task, msg, size, time }; 01120 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SENDX_UNTIL, 4), UR1(2, 3), &arg, SIZARG, 0 }; 01121 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01122 } 01123 return rt_sendx_until(task, msg, size, nano2count(time)); 01124 } 01125 01126 static inline RT_TASK *RT_sendx_timed(unsigned long node, int port, RT_TASK *task, void *msg, int size, RTIME delay) 01127 { 01128 if (node) { 01129 struct { RT_TASK *task; void *msg; long size; RTIME delay; } arg = { task, msg, size, delay }; 01130 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, SENDX_TIMED, 4), UR1(2, 3), &arg, SIZARG, 0 }; 01131 return (RT_TASK *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01132 } 01133 return rt_sendx_timed(task, msg, size, nano2count(delay)); 01134 } 01135 01136 static inline RT_TASK *RT_returnx(unsigned long node, int port, RT_TASK *task, void *msg, int size) 01137 { 01138 01139 if (!task || !node) { 01140 return rt_returnx(task, msg, size); 01141 } 01142 return rt_returnx(rt_find_asgn_stub(OWNER(node, task), 1), msg, size) ? task : 0; 01143 } 01144 01145 static inline RT_TASK *RT_evdrpx(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 01146 { 01147 if (!task || !node) { 01148 return rt_evdrpx(task, msg, size, len); 01149 } 01150 return rt_evdrpx(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 01151 } 01152 01153 static inline RT_TASK *RT_receivex(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 01154 { 01155 if (!task || !node) { 01156 return rt_receivex(task, msg, size, len); 01157 } 01158 return rt_receivex(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 01159 } 01160 01161 static inline RT_TASK *RT_receivex_if(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len) 01162 { 01163 if (!task || !node) { 01164 return rt_receivex_if(task, msg, size, len); 01165 } 01166 return rt_receivex_if(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len) ? task : 0; 01167 } 01168 01169 static inline RT_TASK *RT_receivex_until(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len, RTIME time) 01170 { 01171 if (!task || !node) { 01172 return rt_receivex_until(task, msg, size, len, nano2count(time)); 01173 } 01174 return rt_receivex_until(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len, nano2count(time)) ? task : 0; 01175 } 01176 01177 static inline RT_TASK *RT_receivex_timed(unsigned long node, int port, RT_TASK *task, void *msg, int size, int *len, RTIME delay) 01178 { 01179 if (!task || !node) { 01180 return rt_receivex_timed(task, msg, size, len, nano2count(delay)); 01181 } 01182 return rt_receivex_timed(rt_find_asgn_stub(OWNER(node, task), 1), msg, size, len, nano2count(delay)) ? task : 0; 01183 } 01184 01185 #endif /* CONFIG_RTAI_MSG */ 01186 01187 #if CONFIG_RTAI_MBX 01188 01189 static inline MBX *RT_typed_named_mbx_init(unsigned long node, int port, const char *mbx_name, int size, int qtype) 01190 { 01191 if (node) { 01192 struct { unsigned long mbx_name; long size; long qype; long namelen; } arg = { nam2num(mbx_name), size, qtype, strlen(mbx_name) }; 01193 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, NAMED_MBX_INIT, 0), 0, &arg, SIZARG, 0 }; 01194 return (MBX *)rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).v[LOW]; 01195 } 01196 return (MBX *)rt_typed_named_mbx_init(mbx_name, size, qtype); 01197 } 01198 01199 static inline int RT_named_mbx_delete(unsigned long node, int port, MBX *mbx) 01200 { 01201 if (node) { 01202 struct { MBX *mbx; } arg = { mbx }; 01203 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, NAMED_MBX_DELETE, 0), 0, &arg, SIZARG, 0 }; 01204 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01205 } 01206 return rt_named_mbx_delete(mbx); 01207 } 01208 01209 static inline int RT_mbx_send(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01210 { 01211 if (node) { 01212 struct { MBX *mbx; void *msg; long msg_size; long space; } arg = { mbx, msg, msg_size, 1 }; 01213 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_SEND, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01214 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01215 } 01216 return rt_mbx_send(mbx, msg, msg_size); 01217 } 01218 01219 static inline int RT_mbx_send_wp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01220 { 01221 if (node) { 01222 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01223 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_SEND_WP, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01224 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01225 } 01226 return rt_mbx_send_wp(mbx, msg, msg_size); 01227 } 01228 01229 static inline int RT_mbx_send_if(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01230 { 01231 if (node) { 01232 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01233 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_SEND_IF, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01234 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01235 } 01236 return rt_mbx_send_if(mbx, msg, msg_size); 01237 } 01238 01239 static inline int RT_mbx_ovrwr_send(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01240 { 01241 if (node) { 01242 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01243 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_OVRWR_SEND, 0), UR1(2, 3), &arg, SIZARG, 0 }; 01244 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01245 } 01246 return rt_mbx_ovrwr_send(mbx, msg, msg_size); 01247 } 01248 01249 static inline int RT_mbx_send_until(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME time) 01250 { 01251 if (node) { 01252 struct { MBX *mbx; void *msg; long msg_size; RTIME time; } arg = { mbx, msg, msg_size, time }; 01253 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_SEND_UNTIL, 4), UR1(2, 3), &arg, SIZARG, 0 }; 01254 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01255 } 01256 return rt_mbx_send_until(mbx, msg, msg_size, nano2count(time)); 01257 } 01258 01259 static inline int RT_mbx_send_timed(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME delay) 01260 { 01261 if (node) { 01262 struct { MBX *mbx; void *msg; long msg_size; RTIME delay; } arg = { mbx, msg, msg_size, delay }; 01263 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_SEND_TIMED, 4), UR1(2, 3), &arg, SIZARG, 0 }; 01264 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01265 } 01266 return rt_mbx_send_until(mbx, msg, msg_size, nano2count(delay)); 01267 } 01268 01269 static inline int RT_mbx_evdrp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01270 { 01271 if (node) { 01272 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01273 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_EVDRP, 0), UW1(2, 3), &arg, SIZARG, 0 }; 01274 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01275 } 01276 return rt_mbx_evdrp(mbx, msg, msg_size); 01277 } 01278 01279 static inline int RT_mbx_receive(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01280 { 01281 if (node) { 01282 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01283 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE, 0), UW1(2, 3), &arg, SIZARG, 0 }; 01284 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01285 } 01286 return rt_mbx_receive(mbx, msg, msg_size); 01287 } 01288 01289 static inline int RT_mbx_receive_wp(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01290 { 01291 if (node) { 01292 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01293 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_WP, 0), UW1(2, 3), &arg, SIZARG, 0 }; 01294 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01295 } 01296 return rt_mbx_receive_wp(mbx, msg, msg_size); 01297 } 01298 01299 static inline int RT_mbx_receive_if(unsigned long node, int port, MBX *mbx, void *msg, int msg_size) 01300 { 01301 if (node) { 01302 struct { MBX *mbx; void *msg; long msg_size; } arg = { mbx, msg, msg_size }; 01303 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_IF, 0), UW1(2, 3), &arg, SIZARG, 0 }; 01304 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01305 } 01306 return rt_mbx_receive_if(mbx, msg, msg_size); 01307 } 01308 01309 static inline int RT_mbx_receive_until(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME time) 01310 { 01311 if (node) { 01312 struct { MBX *mbx; void *msg; long msg_size; RTIME time; } arg = { mbx, msg, msg_size, time }; 01313 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_UNTIL, 4), UW1(2, 3), &arg, SIZARG, 0 }; 01314 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01315 } 01316 return rt_mbx_receive_until(mbx, msg, msg_size, nano2count(time)); 01317 } 01318 01319 static inline int RT_mbx_receive_timed(unsigned long node, int port, MBX *mbx, void *msg, int msg_size, RTIME delay) 01320 { 01321 if (node) { 01322 struct { MBX *mbx; void *msg; long msg_size; RTIME delay; } arg = { mbx, msg, msg_size, delay }; 01323 struct { unsigned long fun; long type; void *args; long argsize; long space; } args = { PACKPORT(port, NET_RPC_EXT, MBX_RECEIVE_TIMED, 4), UW1(2, 3), &arg, SIZARG, 0 }; 01324 return rtai_lxrt(NET_RPC_IDX, SIZARGS, NETRPC, &args).i[LOW]; 01325 } 01326 return rt_mbx_receive_timed(mbx, msg, msg_size, nano2count(delay)); 01327 } 01328 01329 static inline int rt_get_net_rpc_ret(MBX *mbx, unsigned long long *retval, void *msg1, int *msglen1, void *msg2, int *msglen2, RTIME timeout, int type) 01330 { 01331 struct { int wsize, w2size; unsigned long long retval; } reply; 01332 int ret; 01333 01334 switch (type) { 01335 case MBX_RECEIVE: 01336 ret = rt_mbx_receive(mbx, &reply, sizeof(reply)); 01337 break; 01338 case MBX_RECEIVE_WP: 01339 ret = rt_mbx_receive_wp(mbx, &reply, sizeof(reply)); 01340 break; 01341 case MBX_RECEIVE_IF: 01342 ret = rt_mbx_receive_if(mbx, &reply, sizeof(reply)); 01343 break; 01344 case MBX_RECEIVE_UNTIL: 01345 ret = rt_mbx_receive_until(mbx, &reply, sizeof(reply), timeout); 01346 break; 01347 case MBX_RECEIVE_TIMED: 01348 ret = rt_mbx_receive_timed(mbx, &reply, sizeof(reply), timeout); 01349 default: 01350 ret = -1; 01351 } 01352 if (!ret) { 01353 *retval = reply.retval; 01354 if (reply.wsize) { 01355 if (*msglen1 > reply.wsize) { 01356 *msglen1 = reply.wsize; 01357 } 01358 rt_mbx_receive(mbx, msg1, *msglen1); 01359 } else { 01360 *msglen1 = 0; 01361 } 01362 if (reply.w2size) { 01363 if (*msglen2 > reply.w2size) { 01364 *msglen2 = reply.w2size; 01365 } 01366 rt_mbx_receive(mbx, msg2, *msglen2); 01367 } else { 01368 *msglen2 = 0; 01369 } 01370 return 0; 01371 } 01372 return ret; 01373 } 01374 01375 #endif /* CONFIG_RTAI_MBX */ 01376 01377 #endif /* __KERNEL__ */ 01378 01379 /* 01380 * A set of compatibility defines for APIs that can be interpreted in various 01381 * ways but do the same the same things always. 01382 */ 01383 01384 #define RT_isrpcx(task) RT_isrpc(task) 01385 01386 #define RT_waiting_return rt_waiting_return 01387 01388 #define RT_sync_net_rpc rt_sync_net_rpc 01389 01390 #define RT_request_port rt_request_port 01391 01392 #define RT_request_port_id rt_request_port_id 01393 01394 #define RT_request_port_mbx rt_request_port_mbx 01395 01396 #define RT_request_port_id_mbx rt_request_port_id_mbx 01397 01398 #define RT_request_soft_port rt_request_soft_port 01399 01400 #define RT_request_soft_port_id rt_request_soft_port_id 01401 01402 #define RT_request_soft_port_mbx rt_request_soft_port_mbx 01403 01404 #define RT_request_soft_port_id_mbx rt_request_soft_port_id_mbx 01405 01406 #define RT_request_hard_port rt_request_hard_port 01407 01408 #define RT_request_hard_port_id rt_request_hard_port_id 01409 01410 #define RT_request_hard_port_mbx rt_request_hard_port_mbx 01411 01412 #define RT_request_hard_port_id_mbx rt_request_hard_port_id_mbx 01413 01414 #define RT_release_port rt_release_port 01415 01416 #define rt_request_port rt_request_soft_port 01417 01418 #define rt_request_port_id rt_request_soft_port_id 01419 01420 #define rt_request_port_mbx rt_request_soft_port_mbx 01421 01422 #define rt_request_port_id_mbx rt_request_soft_port_id_mbx 01423 01424 /* 01425 * End of compatibility defines. 01426 */ 01427 01428 #define rt_request_soft_port(node) \ 01429 rt_send_req_rel_port(node, 0, 0, 0, 0) 01430 01431 #define rt_request_soft_port_id(node, id) \ 01432 rt_send_req_rel_port(node, 0, id, 0, 0) 01433 01434 #define rt_request_soft_port_mbx(node, mbx) \ 01435 rt_send_req_rel_port(node, 0, 0, mbx, 0) 01436 01437 #define rt_request_soft_port_id_mbx(node, id, mbx) \ 01438 rt_send_req_rel_port(node, 0, id, mbx, 0) 01439 01440 #define rt_request_hard_port(node) \ 01441 rt_send_req_rel_port(node, 0, 0, 0, 1) 01442 01443 #define rt_request_hard_port_id(node, id) \ 01444 rt_send_req_rel_port(node, 0, id, 0, 1) 01445 01446 #define rt_request_hard_port_mbx(node, mbx) \ 01447 rt_send_req_rel_port(node, 0, 0, mbx, 1) 01448 01449 #define rt_request_hard_port_id_mbx(node, id, mbx) \ 01450 rt_send_req_rel_port(node, 0, id, mbx, 1) 01451 01452 #define rt_release_port(node, port) \ 01453 rt_send_req_rel_port(node, port, 0, 0, 0) 01454 01455 #endif /* CONFIG_RTAI_INTERNAL_LXRT_SUPPORT */ 01456 01457 #endif /* !_RTAI_NETRPC_H */