Added pointer parameter and embedded pointers to mmrpc_test program.
[ipc/ipcdev.git] / packages / ti / ipc / tests / mmrpc_test.c
1 /*
2  * Copyright (c) 2013, Texas Instruments Incorporated
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  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *  ======== mmrpc_test.c ========
35  */
36 #include <stdio.h>
38 #include <ti/ipc/mm/MmRpc.h>
40 #if defined(SYSLINK_BUILDOS_QNX)
41 #include <ti/shmemallocator/SharedMemoryAllocatorUsr.h>
42 #endif
44 /*
45  *  module 'Mx' functions
46  */
48 /* compute structure */
49 typedef struct {
50     uint32_t    coef;
51     int         key;
52     int         size;
53     uint32_t *  inBuf;
54     uint32_t *  outBuf;
55 } Mx_Compute;
57 int Mx_initialize(void);
58 void Mx_finalize(void);
60 int32_t Mx_triple(uint32_t a);
61 int32_t Mx_add(int32_t a, int32_t b);
62 int32_t Mx_compute(Mx_Compute *compute);
64 MmRpc_Handle Mx_rpcIpu = NULL;
66 /* static function indicies */
67 #define Mx_Fxn_triple   (0x80000000 | 1)
68 #define Mx_Fxn_add      (0x80000000 | 2)
69 #define Mx_Fxn_compute  (0x80000000 | 5)
71 #define Mx_OFFSET(base, member) ((uint_t)(member) - (uint_t)(base))
73 /*
74  *  ======== main ========
75  */
76 int main(int argc, char **argv)
77 {
78     int status;
79     int i;
80     int32_t ret;
81     uint32_t val;
82     Mx_Compute *compute;
83 #if defined(SYSLINK_BUILDOS_QNX)
84     shm_buf shmCompute, shmInBuf, shmOutBuf;
85 #endif
87     printf("mmrpc_test: --> main\n");
89     /* initialize Mx module (setup rpc connection) */
90     status = Mx_initialize();
92     if (status < 0) {
93         goto leave;
94     }
96     /* invoke Mx functions */
97     ret = Mx_triple(11);
98     printf("mmrpc_test: Mx_triple(11), ret=%d\n", ret);
100     if (ret < 0) {
101         status = -1;
102         goto leave;
103     }
105     ret = Mx_triple(111);
106     printf("mmrpc_test: Mx_triple(111), ret=%d\n", ret);
108     if (ret < 0) {
109         status = -1;
110         goto leave;
111     }
113     ret = Mx_add(44, 66);
114     printf("mmrpc_test: Mx_add(44, 66), ret=%d\n", ret);
116     if (ret < 0) {
117         status = -1;
118         goto leave;
119     }
121     /* allocate a compute structure in shared memory */
122 #if defined(SYSLINK_BUILDOS_QNX)
123     SHM_alloc(sizeof(Mx_Compute), &shmCompute);
124     compute = (Mx_Compute *)(shmCompute.vir_addr);
125 #else
126     compute = NULL;
127 #endif
129     if (compute == NULL) {
130         /* temporary: memory alloc not implemented on Linux */
131         goto leave;
132     }
134     /* initialize compute structure */
135     compute->coef = 0x80400000;
136     compute->key = 0xABA0;
137     compute->size = 0x1000;
138     compute->inBuf = NULL;
139     compute->outBuf = NULL;
141     /* allocate an input buffer in shared memory */
142 #if defined(SYSLINK_BUILDOS_QNX)
143     SHM_alloc(compute->size * sizeof(uint32_t), &shmInBuf);
144     compute->inBuf = (uint32_t *)(shmInBuf.vir_addr);
145 #else
146 //  compute->inBuf = ...;
147 #endif
149     if (compute->inBuf == NULL) {
150         printf("mmrpc_test: Error: inBuf == NULL\n");
151         status = -1;
152         goto leave;
153     }
155     /* fill input buffer with seed value */
156     for (i = 0; i < compute->size; i++) {
157         compute->inBuf[i] = 0x2010;
158     }
160     /* allocate an output buffer in shared memory */
161 #if defined(SYSLINK_BUILDOS_QNX)
162     SHM_alloc(compute->size * sizeof(uint32_t), &shmOutBuf);
163     compute->outBuf = (uint32_t *)(shmOutBuf.vir_addr);
164 #else
165 //  compute->outBuf = ...;
166 #endif
168     if (compute->outBuf == NULL) {
169         printf("mmrpc_test: Error: outBuf == NULL\n");
170         status = -1;
171         goto leave;
172     }
174     /* clear output buffer */
175     for (i = 0; i < compute->size; i++) {
176         compute->outBuf[i] = 0;
177     }
179     /* print some debug info */
180     printf("mmrpc_test: calling Mx_compute(0x%x)\n", (unsigned int)compute);
181     printf("mmrpc_test: compute->coef=0x%x\n", compute->coef);
182     printf("mmrpc_test: compute->key=0x%x\n", compute->key);
183     printf("mmrpc_test: compute->size=0x%x\n", compute->size);
184     printf("mmrpc_test: compute->inBuf=0x%x\n", (unsigned int)compute->inBuf);
185     printf("mmrpc_test: compute->outBuf=0x%x\n", (unsigned int)compute->outBuf);
187     /* process the buffer */
188     ret = Mx_compute(compute);
190     if (ret < 0) {
191         status = -1;
192         printf("mmrpc_test: Error: Mx_Compute() failed\n");
193         goto leave;
194     }
196     printf("mmrpc_test: after Mx_compute(0x%x)\n", (unsigned int)compute);
197     printf("mmrpc_test: compute->coef=0x%x\n", compute->coef);
198     printf("mmrpc_test: compute->key=0x%x\n", compute->key);
199     printf("mmrpc_test: compute->size=0x%x\n", compute->size);
200     printf("mmrpc_test: compute->inBuf=0x%x\n", (unsigned int)compute->inBuf);
201     printf("mmrpc_test: compute->outBuf=0x%x\n", (unsigned int)compute->outBuf);
202     printf("mmrpc_test: compute->inBuf[0]=0x%x\n",
203             (unsigned int)compute->inBuf[0]);
204     printf("mmrpc_test: compute->outBuf[0]=0x%x\n",
205             (unsigned int)compute->outBuf[0]);
207     /* check the output buffer */
208     for (i = 0; i < compute->size; i++) {
209         val = compute->outBuf[i] | compute->coef;
210         if (compute->outBuf[i] != val) {
211             status = -1;
212             printf("mmrpc_test: Error: incorrect outBuf\n");
213             break;
214         }
215     }
217     /* free resources */
218 #if defined(SYSLINK_BUILDOS_QNX)
219     SHM_release(&shmOutBuf);
220     SHM_release(&shmInBuf);
221     SHM_release(&shmCompute);
222 #else
223 //  ...
224 #endif
226 leave:
227     /* finalize Mx module (destroy rpc connection) */
228     Mx_finalize();
230     if (status < 0) {
231         printf("mmrpc_test: FAILED\n");
232     }
233     else {
234         printf("mmrpc_test: PASSED\n");
235     }
236     return(0);
239 /*
240  *  ======== Mx_initialize ========
241  */
242 int Mx_initialize(void)
244     int status;
245     MmRpc_Params args;
247     /* create remote server insance */
248     MmRpc_Params_init(&args);
250     status = MmRpc_create("rpc_example", &args, &Mx_rpcIpu);
252     if (status < 0) {
253         printf("mmrpc_test: Error: MmRpc_create failed\n");
254         status = -1;
255     }
256     else {
257         status = 0;
258     }
260     return(status);
263 /*
264  *  ======== Mx_finalize ========
265  */
266 void Mx_finalize(void)
268     /* delete remote server instance */
269     if (Mx_rpcIpu != NULL) {
270         MmRpc_delete(&Mx_rpcIpu);
271     }
274 /*
275  *  ======== Mx_triple ========
276  */
277 int32_t Mx_triple(uint32_t a)
279     MmRpc_FxnCtx *fxnCtx;
280     int32_t fxnRet;
281     char send_buf[512] = {0};
282     int status;
284     /* marshall function arguments into the send buffer */
285     fxnCtx = (MmRpc_FxnCtx *)send_buf;
287     fxnCtx->fxn_id = Mx_Fxn_triple;
288     fxnCtx->num_params = 1;
289     fxnCtx->params[0].type = MmRpc_ParamType_Scalar;
290     fxnCtx->params[0].param.scalar.size = sizeof(int);
291     fxnCtx->params[0].param.scalar.data = a;
292     fxnCtx->num_xlts = 0;
293     fxnCtx->xltAry = NULL;
295     /* invoke the remote function call */
296     status = MmRpc_call(Mx_rpcIpu, fxnCtx, &fxnRet);
298     if (status < 0) {
299         printf("mmrpc_test: Error: MmRpc_call failed\n");
300         fxnRet = -1;
301     }
303     return(fxnRet);
306 /*
307  *  ======== Mx_add ========
308  */
309 int32_t Mx_add(int32_t a, int32_t b)
311     MmRpc_FxnCtx *fxnCtx;
312     int32_t fxnRet;
313     char send_buf[512] = {0};
314     int status;
316     /* marshall function arguments into the send buffer */
317     fxnCtx = (MmRpc_FxnCtx *)send_buf;
319     fxnCtx->fxn_id = Mx_Fxn_add;
320     fxnCtx->num_params = 2;
321     fxnCtx->params[0].type = MmRpc_ParamType_Scalar;
322     fxnCtx->params[0].param.scalar.size = sizeof(int);
323     fxnCtx->params[0].param.scalar.data = a;
324     fxnCtx->params[1].type = MmRpc_ParamType_Scalar;
325     fxnCtx->params[1].param.scalar.size = sizeof(int);
326     fxnCtx->params[1].param.scalar.data = b;
327     fxnCtx->num_xlts = 0;
329     /* invoke the remote function call */
330     status = MmRpc_call(Mx_rpcIpu, fxnCtx, &fxnRet);
332     if (status < 0) {
333         printf("mmrpc_test: Error: MmRpc_call failed\n");
334         fxnRet = -1;
335     }
337     return(fxnRet);
340 /*
341  *  ======== Mx_compute ========
342  */
343 int32_t Mx_compute(Mx_Compute *compute)
345     MmRpc_FxnCtx *fxnCtx;
346     MmRpc_Xlt xltAry[2];
347     int32_t fxnRet;
348     char send_buf[512] = {0};
349     int status;
351     /* marshall function arguments into the send buffer */
352     fxnCtx = (MmRpc_FxnCtx *)send_buf;
354     fxnCtx->fxn_id = Mx_Fxn_compute;
355     fxnCtx->num_params = 1;
356     fxnCtx->params[0].type = MmRpc_ParamType_Ptr;
357     fxnCtx->params[0].param.ptr.size = sizeof(Mx_Compute);
358     fxnCtx->params[0].param.ptr.addr = (size_t)compute;
359 #if defined(SYSLINK_BUILDOS_QNX)
360     fxnCtx->params[0].param.ptr.handle = NULL;
361 #else
362 //  fxnCtx->params[0].param.ptr.handle = ...;
363 #endif
365     fxnCtx->num_xlts = 2;
366     fxnCtx->xltAry = xltAry;
368     fxnCtx->xltAry[0].index = 0;
369     fxnCtx->xltAry[0].offset = MmRpc_OFFSET(compute, &compute->inBuf);
370     fxnCtx->xltAry[0].base = (size_t)(compute->inBuf);
371 #if defined(SYSLINK_BUILDOS_QNX)
372     fxnCtx->xltAry[0].handle = NULL;
373 #else
374 //  fxnCtx->xltAry[0].handle = ...;
375 #endif
377     fxnCtx->xltAry[1].index = 0;
378     fxnCtx->xltAry[1].offset = MmRpc_OFFSET(compute, &compute->outBuf);
379     fxnCtx->xltAry[1].base = (size_t)(compute->outBuf);
380 #if defined(SYSLINK_BUILDOS_QNX)
381     fxnCtx->xltAry[1].handle = NULL;
382 #else
383 //  fxnCtx->xltAry[1].handle = ...;
384 #endif
386     /* invoke the remote function call */
387     status = MmRpc_call(Mx_rpcIpu, fxnCtx, &fxnRet);
389     if (status < 0) {
390         printf("mmrpc_test: Error: MmRpc_call failed\n");
391         fxnRet = -1;
392     }
394     return(fxnRet);