Added pointer parameter and embedded pointers to mmrpc_test program.
[ipc/ipcdev.git] / packages / ti / ipc / tests / rpc_task.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  */
32 /*
33  *  ======== rpc_task.c ========
34  *
35  *  Example of setting up a 'RPC' service with the ServiceMgr, allowing clients
36  *  to instantiate the example RPC instance.
37  *
38  */
40 #include <xdc/std.h>
41 #include <xdc/cfg/global.h>
42 #include <xdc/runtime/System.h>
43 #include <xdc/runtime/Diags.h>
45 #include <stdio.h>
46 #include <string.h>
47 #include <stdlib.h>
49 #include <ti/ipc/MultiProc.h>
50 #include <ti/sysbios/BIOS.h>
51 #include <ti/sysbios/knl/Task.h>
53 #include <ti/grcm/RcmTypes.h>
54 #include <ti/grcm/RcmServer.h>
56 #include <ti/srvmgr/ServiceMgr.h>
57 #include <ti/srvmgr/omaprpc/OmapRpc.h>
58 #include <ti/srvmgr/rpmsg_omx.h>
59 #include <ti/srvmgr/omx_packet.h>
61 #include <ti/sysbios/hal/Cache.h>
63 /* Turn on/off printf's */
64 #define CHATTER 1
66 #define RPC_MGR_PORT    59
68 void start_rpc_task(); /* bootstrap function */
70 typedef struct {
71     Int a;
72     Int b;
73     Int c;
74 } FxnAdd3Args;
76 typedef struct {
77     Int num;
78     Int *array;
79 } FxnAddXArgs;
81 #define H264_DECODER_NAME   "H264_decoder"
83 #define OMX_VIDEO_THREAD_PRIORITY    5
85 typedef UInt32 OMX_HANDLETYPE;
87 //static Int32 RPC_SKEL_Init(Void *, UInt32 size, UInt32 *data);
88 static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data);
89 //static Int32 RPC_SKEL_SetParameter(UInt32 size, UInt32 *data);
90 //static Int32 RPC_SKEL_GetParameter(UInt32 size, UInt32 *data);
91 static Int32 fxnTriple(UInt32 size, UInt32 *data);
92 static Int32 fxnAdd(UInt32 size, UInt32 *data);
93 static Int32 fxnAdd3(UInt32 size, UInt32 *data);
94 static Int32 fxnAddX(UInt32 size, UInt32 *data);
95 static Int32 fxnCompute(UInt32 size, UInt32 *data);
97 #if 0
98 /* RcmServer static function table */
99 static RcmServer_FxnDesc RPCServerFxnAry[] = {
100     {"RPC_SKEL_Init", NULL}, /* filled in dynamically */
101     {"RPC_SKEL_SetParameter", RPC_SKEL_SetParameter},
102     {"RPC_SKEL_GetParameter", RPC_SKEL_GetParameter},
103     {"fxnTriple", fxnTriple },
104 };
106 #define RPCServerFxnAryLen (sizeof RPCServerFxnAry / sizeof RPCServerFxnAry[0])
108 static const RcmServer_FxnDescAry RPCServer_fxnTab = {
109     RPCServerFxnAryLen,
110     RPCServerFxnAry
111 };
112 #endif
114 #define RPC_SVR_NUM_FXNS 6
115 OmapRpc_FuncDeclaration RPCServerFxns[RPC_SVR_NUM_FXNS] =
117     { RPC_SKEL_Init2,
118         { "RPC_SKEL_Init2", 3,
119             {
120                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
121                 {OmapRpc_Direction_In, OmapRpc_Param_U32, 1},
122                 {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_U32), 1}
123             }
124         }
125     },
126     { fxnTriple,
127         { "fxnTriple", 2,
128             {
129                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
130                 {OmapRpc_Direction_In, OmapRpc_Param_U32, 1}
131             }
132         }
133     },
134     { fxnAdd,
135         { "fxnAdd", 3,
136             {
137                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
138                 {OmapRpc_Direction_In, OmapRpc_Param_S32, 1},
139                 {OmapRpc_Direction_In, OmapRpc_Param_S32, 1}
140             }
141         }
142     },
143     { fxnAdd3,
144         { "fxnAdd3", 2,
145             {
146                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
147                 {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_U32), 1}
148             }
149         }
150     },
151     { fxnAddX,
152         { "fxnAddX", 2,
153             {
154                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
155                 {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_U32), 1}
156             }
157         }
158     },
159     { fxnCompute,
160         { "fxnCompute", 1,
161             {
162                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
163                 {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_VOID), 1}
164             }
165         }
166     }
167 };
169 #if 0
170 static Int32 RPC_SKEL_SetParameter(UInt32 size, UInt32 *data)
172 #if CHATTER
173     System_printf("RPC_SKEL_SetParameter: Called\n");
174 #endif
176     return(0);
178 #endif
180 #if 0
181 static Int32 RPC_SKEL_GetParameter(UInt32 size, UInt32 *data)
183 #if CHATTER
184     System_printf("RPC_SKEL_GetParameter: Called\n");
185 #endif
187     return(0);
189 #endif
191 Void RPC_SKEL_SrvDelNotification()
193     System_printf("RPC_SKEL_SrvDelNotification: Nothing to cleanup\n");
196 #define CALLBACK_DATA      "OMX_Callback"
197 #define PAYLOAD_SIZE       sizeof(CALLBACK_DATA)
198 #define CALLBACK_DATA_SIZE (HDRSIZE + OMXPACKETSIZE + PAYLOAD_SIZE)
200 #if 0
201 static Int32 RPC_SKEL_Init(Void *srvc, UInt32 size, UInt32 *data)
203     char              cComponentName[128] = {0};
204     OMX_HANDLETYPE    hComp;
205     Char              cb_data[HDRSIZE + OMXPACKETSIZE + PAYLOAD_SIZE] =  {0};
207     /*
208      * Note: Currently, rpmsg_omx linux driver expects an omx_msg_hdr in front
209      * of the omx_packet data, so we allow space for this:
210      */
211     struct omx_msg_hdr * hdr = (struct omx_msg_hdr *)cb_data;
212     struct omx_packet  * packet = (struct omx_packet *)hdr->data;
215     //Marshalled:[>offset(cParameterName)|>pAppData|>offset(RcmServerName)|>pid|
216     //>--cComponentName--|>--CallingCorercmServerName--|
217     //<hComp]
219     strcpy(cComponentName, (char *)data + sizeof(map_info_type));
221 #if CHATTER
222     System_printf("RPC_SKEL_GetHandle: Component Name received: %s\n",
223                   cComponentName);
224 #endif
226     /* Simulate sending an async OMX callback message, passing an omx_packet
227      * structure.
228      */
229     packet->msg_id  = 99;   // Set to indicate callback instance, buffer id, etc.
230     packet->fxn_idx = 5;    // Set to indicate callback fxn
231     packet->data_size = PAYLOAD_SIZE;
232     strcpy((char *)packet->data, CALLBACK_DATA);
234 #if CHATTER
235     System_printf("RPC_SKEL_GetHandle: Sending callback message id: %d, "
236                   "fxn_id: %d, data: %s\n",
237                   packet->msg_id, packet->fxn_idx, packet->data);
238 #endif
239     ServiceMgr_send(srvc, cb_data, CALLBACK_DATA_SIZE);
241     /* Call OMX_Get_Handle() and return handle for future calls. */
242     //eCompReturn = OMX_GetHandle(&hComp, (OMX_STRING)&cComponentName[0], pAppData,&rpcCallBackInfo);
243     hComp = 0x5C0FFEE5;
244     data[0] = hComp;
246 #if CHATTER
247     System_printf("RPC_SKEL_GetHandle: returning hComp: 0x%x\n", hComp);
248 #endif
250     return(0);
252 #endif
254 static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data)
256     System_printf("RPC_SKEL_Init2: size = 0x%x data = 0x%x\n", size,
257                                                             (UInt32)data);
258     return 0;
261 /*
262  *  ======== fxnTriple ========
263  */
264 Int32 fxnTriple(UInt32 size, UInt32 *data)
266     struct OmapRpc_Parameter *payload = (struct OmapRpc_Parameter *)data;
267     Int a;
268     Int32 result;
270     a = (Int)payload[0].data;
271     result = a * 3;
273 #if CHATTER
274     System_printf("fxnTriple: a=%d, result=%d\n", a, result);
275 #endif
277     return(result);
280 /*
281  *  ======== fxnAdd ========
282  */
283 Int32 fxnAdd(UInt32 size, UInt32 *data)
285     struct OmapRpc_Parameter *payload = (struct OmapRpc_Parameter *)data;
286     Int a, b;
287     Int32 result;
289     a = (Int)payload[0].data;
290     b = (Int)payload[1].data;
292     result = a + b;
294 #if CHATTER
295     System_printf("fxnAdd: a=%d, b=%d, result=%d\n", a, b, result);
296 #endif
298     return(result);
301 /*
302  *  ======== fxnCompute ========
303  */
304 Int32 fxnCompute(UInt32 size, UInt32 *data)
306     typedef struct {
307         uint32_t    coef;
308         int         key;
309         int         size;
310         uint32_t *  inBuf;
311         uint32_t *  outBuf;
312     } Mx_Compute;
314     struct OmapRpc_Parameter *payload;
315     Mx_Compute *compute;
316     Int32 result = 0;
317     Int i;
319     payload = (struct OmapRpc_Parameter *)data;
320     compute = (Mx_Compute *)payload[0].data;
321     Cache_inv(compute, sizeof(Mx_Compute), Cache_Type_ALL, TRUE);
323 #if CHATTER
324     System_printf("fxnCompute: compute=0x%x\n", compute);
325     System_printf("fxnCompute: compute size=%d\n", (Int)payload[0].size);
326     System_printf("fxnCompute: coef=0x%x\n", compute->coef);
327     System_printf("fxnCompute: key=0x%x\n", compute->key);
328     System_printf("fxnCompute: size=0x%x\n", compute->size);
329     System_printf("fxnCompute: inBuf=0x%x\n", compute->inBuf);
330     System_printf("fxnCompute: outBuf=0x%x\n", compute->outBuf);
331 #endif
333     Cache_inv(compute->inBuf, compute->size * sizeof(uint32_t),
334             Cache_Type_ALL, TRUE);
335     Cache_inv(compute->outBuf, compute->size * sizeof(uint32_t),
336             Cache_Type_ALL, TRUE);
338     for (i = 0; i < compute->size; i++) {
339         compute->outBuf[i] = compute->coef | compute->inBuf[i];
340     }
342     Cache_wbInv(compute->outBuf, compute->size * sizeof(uint32_t),
343             Cache_Type_ALL, TRUE);
345     return(result);
348 /*
349  *  ======== fxnAdd3 ========
350  */
351 Int32 fxnAdd3(UInt32 size, UInt32 *data)
353     struct OmapRpc_Parameter *payload = (struct OmapRpc_Parameter *)data;
354     FxnAdd3Args *args;
355     Int a, b, c;
357     args = (FxnAdd3Args *)payload[0].data;
359     Cache_inv (args, sizeof(FxnAdd3Args), Cache_Type_ALL, TRUE);
361     a = args->a;
362     b = args->b;
363     c = args->c;
365 #if CHATTER
366     System_printf("fxnAdd3: a=%d, b=%d, c=%d\n", a, b, c);
367 #endif
369     return(a + b + c);
372 /*
373  *  ======== fxnAddX ========
374  */
375 Int32 fxnAddX(UInt32 size, UInt32 *data)
377     struct OmapRpc_Parameter *payload = (struct OmapRpc_Parameter *)data;
378     FxnAddXArgs *args;
379     Int num, i, sum = 0;
380     Int *array;
382     args = (FxnAddXArgs *)payload[0].data;
384     Cache_inv (args, sizeof(FxnAddXArgs), Cache_Type_ALL, TRUE);
386     num = args->num;
387     array = args->array;
389     Cache_inv (array, sizeof(Int) * num, Cache_Type_ALL, TRUE);
391 #if CHATTER
392     System_printf("fxnAddX: ");
393 #endif
394     for (i = 0; i < num; i++) {
395 #if CHATTER
396         System_printf(" a[%d]=%d,", i, array[i]);
397 #endif
398         sum += array[i];
399     }
401 #if CHATTER
402     System_printf(" sum=%d\n", sum);
403 #endif
405     return(sum);
408 /*
409  *  ======== start_rpc_task ========
410  */
411 void start_rpc_task(void)
413     /* Init service manager */
414     System_printf("%s initializing OMAPRPC based service manager endpoint\n",
415                     MultiProc_getName(MultiProc_self()));
417     OmapRpc_createChannel("rpc_example", MultiProc_getId("HOST"),
418                           RPC_MGR_PORT, RPC_SVR_NUM_FXNS, RPCServerFxns,
419                           (OmapRpc_SrvDelNotifyFxn)RPC_SKEL_SrvDelNotification);