← Back to branch summary

~vojtech-horky/helenos/numa

« back to all changes in this revision

Viewing changes to uspace/lib/libc/include/ipc/ipc.h

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/lib/libc/include/ipc/ipc.h
 
1
/*
 
2
 * Copyright (c) 2006 Ondrej Palkovsky
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * - Redistributions of source code must retain the above copyright
 
10
 *   notice, this list of conditions and the following disclaimer.
 
11
 * - Redistributions in binary form must reproduce the above copyright
 
12
 *   notice, this list of conditions and the following disclaimer in the
 
13
 *   documentation and/or other materials provided with the distribution.
 
14
 * - The name of the author may not be used to endorse or promote products
 
15
 *   derived from this software without specific prior written permission.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
 */
 
28
 
 
29
/** @addtogroup libcipc
 
30
 * @{
 
31
 */
 
32
/** @file
 
33
 */
 
34
 
 
35
#ifndef LIBIPC_IPC_H_
 
36
#define LIBIPC_IPC_H_
 
37
 
 
38
#include <task.h>
 
39
#include <kernel/ipc/ipc.h>
 
40
#include <kernel/ddi/irq.h>
 
41
#include <sys/types.h>
 
42
#include <kernel/synch/synch.h>
 
43
 
 
44
#define IPC_FLAG_BLOCKING  0x01
 
45
 
 
46
typedef sysarg_t ipcarg_t;
 
47
 
 
48
typedef struct {
 
49
        ipcarg_t args[IPC_CALL_LEN];
 
50
        ipcarg_t in_phone_hash;
 
51
} ipc_call_t;
 
52
 
 
53
typedef sysarg_t ipc_callid_t;
 
54
 
 
55
typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
 
56
 
 
57
/*
 
58
 * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
 
59
 * They are in the form ipc_call_sync_m_n(), where m denotes the number of
 
60
 * arguments of payload and n denotes number of return values. Whenever
 
61
 * possible, the fast version is used.
 
62
 */
 
63
#define ipc_call_sync_0_0(phoneid, method) \
 
64
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0)
 
65
#define ipc_call_sync_0_1(phoneid, method, res1) \
 
66
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), 0, 0, 0, 0)
 
67
#define ipc_call_sync_0_2(phoneid, method, res1, res2) \
 
68
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), 0, 0, 0)
 
69
#define ipc_call_sync_0_3(phoneid, method, res1, res2, res3) \
 
70
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
 
71
            0, 0)
 
72
#define ipc_call_sync_0_4(phoneid, method, res1, res2, res3, res4) \
 
73
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
 
74
            (res4), 0)
 
75
#define ipc_call_sync_0_5(phoneid, method, res1, res2, res3, res4, res5) \
 
76
        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
 
77
            (res4), (res5))
 
78
 
 
79
#define ipc_call_sync_1_0(phoneid, method, arg1) \
 
80
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, 0, 0, 0, 0, 0)
 
81
#define ipc_call_sync_1_1(phoneid, method, arg1, res1) \
 
82
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), 0, 0, 0, 0)
 
83
#define ipc_call_sync_1_2(phoneid, method, arg1, res1, res2) \
 
84
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), 0, \
 
85
            0, 0)
 
86
#define ipc_call_sync_1_3(phoneid, method, arg1, res1, res2, res3) \
 
87
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
 
88
            (res3), 0, 0)
 
89
#define ipc_call_sync_1_4(phoneid, method, arg1, res1, res2, res3, res4) \
 
90
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
 
91
            (res3), (res4), 0)
 
92
#define ipc_call_sync_1_5(phoneid, method, arg1, res1, res2, res3, res4, \
 
93
    res5) \
 
94
        ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
 
95
            (res3), (res4), (res5))
 
96
 
 
97
#define ipc_call_sync_2_0(phoneid, method, arg1, arg2) \
 
98
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, 0, 0, 0, \
 
99
            0, 0)
 
100
#define ipc_call_sync_2_1(phoneid, method, arg1, arg2, res1) \
 
101
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), 0, 0, \
 
102
            0, 0)
 
103
#define ipc_call_sync_2_2(phoneid, method, arg1, arg2, res1, res2) \
 
104
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
 
105
            (res2), 0, 0, 0)
 
106
#define ipc_call_sync_2_3(phoneid, method, arg1, arg2, res1, res2, res3) \
 
107
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
 
108
            (res2), (res3), 0, 0)
 
109
#define ipc_call_sync_2_4(phoneid, method, arg1, arg2, res1, res2, res3, \
 
110
    res4) \
 
111
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
 
112
            (res2), (res3), (res4), 0)
 
113
#define ipc_call_sync_2_5(phoneid, method, arg1, arg2, res1, res2, res3, \
 
114
    res4, res5)\
 
115
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
 
116
            (res2), (res3), (res4), (res5))
 
117
 
 
118
#define ipc_call_sync_3_0(phoneid, method, arg1, arg2, arg3) \
 
119
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, 0, 0, \
 
120
            0, 0)
 
121
#define ipc_call_sync_3_1(phoneid, method, arg1, arg2, arg3, res1) \
 
122
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
 
123
            0, 0, 0, 0)
 
124
#define ipc_call_sync_3_2(phoneid, method, arg1, arg2, arg3, res1, res2) \
 
125
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
 
126
            (res2), 0, 0, 0)
 
127
#define ipc_call_sync_3_3(phoneid, method, arg1, arg2, arg3, res1, res2, \
 
128
    res3) \
 
129
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
 
130
            (res1), (res2), (res3), 0, 0)
 
131
#define ipc_call_sync_3_4(phoneid, method, arg1, arg2, arg3, res1, res2, \
 
132
    res3, res4) \
 
133
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
 
134
            (res1), (res2), (res3), (res4), 0)
 
135
#define ipc_call_sync_3_5(phoneid, method, arg1, arg2, arg3, res1, res2, \
 
136
    res3, res4, res5) \
 
137
        ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
 
138
            (res1), (res2), (res3), (res4), (res5))
 
139
 
 
140
#define ipc_call_sync_4_0(phoneid, method, arg1, arg2, arg3, arg4) \
 
141
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
 
142
            0, 0, 0, 0, 0)
 
143
#define ipc_call_sync_4_1(phoneid, method, arg1, arg2, arg3, arg4, res1) \
 
144
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
 
145
            (res1), 0, 0, 0, 0)
 
146
#define ipc_call_sync_4_2(phoneid, method, arg1, arg2, arg3, arg4, res1, res2) \
 
147
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
 
148
            (res1), (res2), 0, 0, 0)
 
149
#define ipc_call_sync_4_3(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
 
150
    res3) \
 
151
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
152
            (arg4), 0, (res1), (res2), (res3), 0, 0)
 
153
#define ipc_call_sync_4_4(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
 
154
    res3, res4) \
 
155
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
156
            (arg4), 0, (res1), (res2), (res3), (res4), 0)
 
157
#define ipc_call_sync_4_5(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
 
158
    res3, res4, res5) \
 
159
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
160
            (arg4), 0, (res1), (res2), (res3), (res4), (res5))
 
161
 
 
162
#define ipc_call_sync_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \
 
163
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
 
164
            (arg5), 0, 0, 0, 0, 0)
 
165
#define ipc_call_sync_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1) \
 
166
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
 
167
            (arg5), (res1), 0, 0, 0, 0)
 
168
#define ipc_call_sync_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
 
169
    res2) \
 
170
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
171
            (arg4), (arg5), (res1), (res2), 0, 0, 0)
 
172
#define ipc_call_sync_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
 
173
    res2, res3) \
 
174
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
175
            (arg4), (arg5), (res1), (res2), (res3), 0, 0)
 
176
#define ipc_call_sync_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
 
177
    res2, res3, res4) \
 
178
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
179
            (arg4), (arg5), (res1), (res2), (res3), (res4), 0)
 
180
#define ipc_call_sync_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
 
181
    res2, res3, res4, res5) \
 
182
        ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
183
            (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
 
184
 
 
185
extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
186
    ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
 
187
 
 
188
extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
189
    ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
 
190
    ipcarg_t *);
 
191
 
 
192
extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
 
193
extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
 
194
 
 
195
static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
 
196
{
 
197
        return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
 
198
}
 
199
 
 
200
extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
 
201
 
 
202
/*
 
203
 * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
 
204
 * They are in the form of ipc_answer_m(), where m is the number of return
 
205
 * arguments. The macros decide between the fast and the slow version according
 
206
 * to m.
 
207
 */
 
208
#define ipc_answer_0(callid, retval) \
 
209
        ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
 
210
#define ipc_answer_1(callid, retval, arg1) \
 
211
        ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0)
 
212
#define ipc_answer_2(callid, retval, arg1, arg2) \
 
213
        ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0)
 
214
#define ipc_answer_3(callid, retval, arg1, arg2, arg3) \
 
215
        ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0)
 
216
#define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \
 
217
        ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4))
 
218
#define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
 
219
        ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
 
220
 
 
221
extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
222
    ipcarg_t, ipcarg_t);
 
223
extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
224
    ipcarg_t, ipcarg_t, ipcarg_t);
 
225
 
 
226
/*
 
227
 * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow().
 
228
 * They are in the form of ipc_call_async_m(), where m is the number of payload
 
229
 * arguments. The macros decide between the fast and the slow version according
 
230
 * to m.
 
231
 */
 
232
#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
 
233
        ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
 
234
            (callback), (can_preempt))
 
235
#define ipc_call_async_1(phoneid, method, arg1, private, callback, \
 
236
    can_preempt) \
 
237
        ipc_call_async_fast((phoneid), (method), (arg1), 0, 0, 0, (private), \
 
238
            (callback), (can_preempt))
 
239
#define ipc_call_async_2(phoneid, method, arg1, arg2, private, callback, \
 
240
    can_preempt) \
 
241
        ipc_call_async_fast((phoneid), (method), (arg1), (arg2), 0, 0, \
 
242
            (private), (callback), (can_preempt))
 
243
#define ipc_call_async_3(phoneid, method, arg1, arg2, arg3, private, callback, \
 
244
    can_preempt) \
 
245
        ipc_call_async_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \
 
246
            (private), (callback), (can_preempt))
 
247
#define ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, private, \
 
248
    callback, can_preempt) \
 
249
        ipc_call_async_fast((phoneid), (method), (arg1), (arg2), (arg3), \
 
250
            (arg4), (private), (callback), (can_preempt))
 
251
#define ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, \
 
252
    private, callback, can_preempt) \
 
253
        ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 
254
            (arg4), (arg5), (private), (callback), (can_preempt))
 
255
 
 
256
extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
257
    ipcarg_t, void *, ipc_async_callback_t, int);
 
258
extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
 
259
    ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
 
260
 
 
261
extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
 
262
extern int ipc_connect_me_to(int, int, int, int);
 
263
extern int ipc_connect_me_to_blocking(int, int, int, int);
 
264
extern int ipc_hangup(int);
 
265
extern int ipc_register_irq(int, int, int, irq_code_t *);
 
266
extern int ipc_unregister_irq(int, int);
 
267
extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
 
268
extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
 
269
    ipcarg_t, ipcarg_t, ipcarg_t, int);
 
270
 
 
271
/*
 
272
 * User-friendly wrappers for ipc_share_in_start().
 
273
 */
 
274
#define ipc_share_in_start_0_0(phoneid, dst, size) \
 
275
        ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
 
276
#define ipc_share_in_start_0_1(phoneid, dst, size, flags) \
 
277
        ipc_share_in_start((phoneid), (dst), (size), 0, (flags))
 
278
#define ipc_share_in_start_1_0(phoneid, dst, size, arg) \
 
279
        ipc_share_in_start((phoneid), (dst), (size), (arg), NULL)
 
280
#define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
 
281
        ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
 
282
 
 
283
extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
 
284
extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
 
285
extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
 
286
extern int ipc_share_out_start(int, void *, int);
 
287
extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
 
288
extern int ipc_share_out_finalize(ipc_callid_t, void *);
 
289
extern int ipc_data_read_start(int, void *, size_t);
 
290
extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
 
291
extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
 
292
extern int ipc_data_write_start(int, const void *, size_t);
 
293
extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
 
294
extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
 
295
 
 
296
extern int ipc_connect_kbox(task_id_t);
 
297
 
 
298
#endif
 
299
 
 
300
/** @}
 
301
 */