MxServer_compute: Incremented num params from 1 to 2 to match signature.
[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  */
33 /*
34  *  ======== rpc_task.c ========
35  *
36  *  Example of how to integrate the MxServer module with the
37  *  MmService manager.
38  */
40 #include <xdc/std.h>
41 #include <xdc/runtime/System.h>
43 #include <ti/grcm/RcmServer.h>
44 #include <ti/ipc/mm/MmType.h>
45 #include <ti/ipc/mm/MmServiceMgr.h>
46 #include <ti/sysbios/hal/Cache.h>
47 #include <ti/ipc/MultiProc.h>
49 #include "MxServer.h"
51 /* turn on/off printf's */
52 #define CHATTER 1
54 typedef struct {
55     Int a;
56     Int b;
57     Int c;
58 } FxnAdd3Args;
60 typedef struct {
61     Int num;
62     Int *array;
63 } FxnAddXArgs;
66 #define SERVICE_NAME "rpc_example"
68 /* MxServer skel function declarations */
69 static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data);
70 static Int32 MxServer_skel_triple(UInt32 size, UInt32 *data);
71 static Int32 MxServer_skel_add(UInt32 size, UInt32 *data);
72 static Int32 fxnAdd3(UInt32 size, UInt32 *data);
73 static Int32 fxnAddX(UInt32 size, UInt32 *data);
74 static Int32 MxServer_skel_compute(UInt32 size, UInt32 *data);
75 static Int32 fxnFault(UInt32 size, UInt32 *data);
77 /* MxServer skel function array */
78 static RcmServer_FxnDesc mxSkelAry[] = {
79     { "RPC_SKEL_Init2",         RPC_SKEL_Init2          },
80     { "MxServer_triple",        MxServer_skel_triple    },
81     { "MxServer_add",           MxServer_skel_add       },
82     { "fxnAdd3",                fxnAdd3                 },
83     { "fxnAddX",                fxnAddX                 },
84     { "MxServer_compute",       MxServer_skel_compute   },
85     { "fxnFault",               fxnFault                }
86 };
88 /* MxServer skel function table */
89 static const RcmServer_FxnDescAry rpc_fxnTab = {
90     (sizeof(mxSkelAry) / sizeof(mxSkelAry[0])),
91     mxSkelAry
92 };
94 static MmType_FxnSig rpc_sigAry[] = {
95     { "RPC_SKEL_Init2", 3,
96         {
97             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
98             { MmType_Dir_In,  MmType_Param_U32, 1 },
99             { MmType_Dir_In,  MmType_PtrType(MmType_Param_U32), 1 }
100         }
101     },
102     { "MxServer_triple", 2,
103         {
104             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
105             { MmType_Dir_In,  MmType_Param_U32, 1 }
106         }
107     },
108     { "MxServer_add", 3,
109         {
110             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
111             { MmType_Dir_In,  MmType_Param_S32, 1 },
112             { MmType_Dir_In,  MmType_Param_S32, 1 }
113         }
114     },
115     { "fxnAdd3", 2,
116         {
117             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
118             { MmType_Dir_In,  MmType_PtrType(MmType_Param_U32), 1 }
119         }
120     },
121     { "fxnAddX", 2,
122         {
123             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
124             { MmType_Dir_In,  MmType_PtrType(MmType_Param_U32), 1 }
125         }
126     },
127     { "MxServer_compute", 2,
128         {
129             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
130             { MmType_Dir_In,  MmType_PtrType(MmType_Param_VOID), 1 }
131         }
132     },
133     { "fxnFault", 2,
134         {
135             { MmType_Dir_Out, MmType_Param_S32, 1 }, /* return */
136             { MmType_Dir_In,  MmType_PtrType(MmType_Param_U32), 1 }
137         }
138     }
139 };
141 static MmType_FxnSigTab rpc_fxnSigTab = {
142     MmType_NumElem(rpc_sigAry), rpc_sigAry
143 };
145 /* the server create parameters, must be in persistent memory */
146 static RcmServer_Params rpc_Params;
149 Void RPC_SKEL_SrvDelNotification(Void)
151     System_printf("RPC_SKEL_SrvDelNotification: Nothing to cleanup\n");
154 static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data)
156     System_printf("RPC_SKEL_Init2: size=0x%x data=0x%x\n", size, data);
157     return(0);
160 /*
161  *  ======== MxServer_skel_triple ========
162  */
163 Int32 MxServer_skel_triple(UInt32 size, UInt32 *data)
165     MmType_Param *payload = (MmType_Param *)data;
166     UInt32 a;
167     Int32 result;
169     a = (UInt32)payload[0].data;
170     result = MxServer_triple(a);
172 #if CHATTER
173     System_printf("fxnTriple: a=%d, result=%d\n", a, result);
174 #endif
176     return(result);
179 /*
180  *  ======== MxServer_skel_add ========
181  */
182 Int32 MxServer_skel_add(UInt32 size, UInt32 *data)
184     MmType_Param *payload = (MmType_Param *)data;
185     Int32 a, b;
186     Int32 result;
188     a = (Int32)payload[0].data;
189     b = (Int32)payload[1].data;
191     result = MxServer_add(a, b);
193 #if CHATTER
194     System_printf("fxnAdd: a=%d, b=%d, result=%d\n", a, b, result);
195 #endif
197     return(result);
200 /*
201  *  ======== fxnAdd3 ========
202  */
203 Int32 fxnAdd3(UInt32 size, UInt32 *data)
205     MmType_Param *payload = (MmType_Param *)data;
206     FxnAdd3Args *args;
207     Int a, b, c;
209     args = (FxnAdd3Args *)payload[0].data;
211     Cache_inv (args, sizeof(FxnAdd3Args), Cache_Type_ALL, TRUE);
213     a = args->a;
214     b = args->b;
215     c = args->c;
217 #if CHATTER
218     System_printf("fxnAdd3: a=%d, b=%d, c=%d\n", a, b, c);
219 #endif
221     return(a + b + c);
224 /*
225  *  ======== fxnAddX ========
226  */
227 Int32 fxnAddX(UInt32 size, UInt32 *data)
229     MmType_Param *payload = (MmType_Param *)data;
230     FxnAddXArgs *args;
231     Int num, i, sum = 0;
232     Int *array;
234     args = (FxnAddXArgs *)payload[0].data;
236     Cache_inv (args, sizeof(FxnAddXArgs), Cache_Type_ALL, TRUE);
238     num = args->num;
239     array = args->array;
241     Cache_inv (array, sizeof(Int) * num, Cache_Type_ALL, TRUE);
243 #if CHATTER
244     System_printf("fxnAddX: ");
245 #endif
246     for (i = 0; i < num; i++) {
247 #if CHATTER
248         System_printf(" a[%d]=%d,", i, array[i]);
249 #endif
250         sum += array[i];
251     }
253 #if CHATTER
254     System_printf(" sum=%d\n", sum);
255 #endif
257     return(sum);
260 /*
261  *  ======== MxServer_skel_compute ========
262  */
263 Int32 MxServer_skel_compute(UInt32 size, UInt32 *data)
265     MmType_Param *payload;
266     MxServer_Compute *compute;
267     Int32 result = 0;
269     payload = (MmType_Param *)data;
270     compute = (MxServer_Compute *)payload[0].data;
272 #if CHATTER
273     System_printf("skel_compute: compute=0x%x\n", compute);
274     System_printf("skel_compute: compute size=%d\n", (Int)payload[0].size);
275     System_printf("skel_compute: coef=0x%x\n", compute->coef);
276     System_printf("skel_compute: key=0x%x\n", compute->key);
277     System_printf("skel_compute: size=0x%x\n", compute->size);
278     System_printf("skel_compute: inBuf=0x%x\n", compute->inBuf);
279     System_printf("skel_compute: outBuf=0x%x\n", compute->outBuf);
280 #endif
282     Cache_inv(compute->inBuf, compute->size * sizeof(uint32_t),
283             Cache_Type_ALL, TRUE);
284     Cache_inv(compute->outBuf, compute->size * sizeof(uint32_t),
285             Cache_Type_ALL, TRUE);
287     /* invoke the implementation function */
288     result = MxServer_compute(compute);
290     Cache_wbInv(compute->outBuf, compute->size * sizeof(uint32_t),
291             Cache_Type_ALL, TRUE);
293     return(result);
296 /*
297  *  ======== fxnAddX ========
298  */
299 Int32 fxnFault(UInt32 size, UInt32 *data)
301     MmType_Param *payload = (MmType_Param *)data;
302     Int a;
304     a = (UInt32)payload[0].data;
306     switch (a) {
307         case 1:
308             System_printf("Generating read MMU Fault...\n");
309             a = *(volatile int *)(0x96000000);
310             break;
311         case 2:
312             System_printf("Generating write MMU Fault...\n");
313             *(volatile int *)(0x96000000) = 0x1;
314             break;
315         default:
316             System_printf("Invalid fxnFault test\n");
317             break;
318     }
320     return(0);
323 /*
324  *  ======== register_MxServer ========
325  *
326  *  Bootstrap function, must be configured in BIOS.addUserStartupFunctions.
327  */
328 void register_MxServer(void)
330     Int status = MmServiceMgr_S_SUCCESS;
331     Char mMServerName[20];
333     System_printf("register_MxServer: -->\n");
335     /* must initialize these modules before using them */
336     RcmServer_init();
337     MmServiceMgr_init();
339     /* setup the server create params */
340     RcmServer_Params_init(&rpc_Params);
341     rpc_Params.priority = Thread_Priority_ABOVE_NORMAL;
342     rpc_Params.stackSize = 0x1000;
343     rpc_Params.fxns.length = rpc_fxnTab.length;
344     rpc_Params.fxns.elem = rpc_fxnTab.elem;
346     /* Construct an MMServiceMgr name adorned with core name: */
347     System_sprintf(mMServerName, "%s_%d", SERVICE_NAME,
348                    MultiProc_self());
350     /* register an example service */
351     status = MmServiceMgr_register(mMServerName, &rpc_Params, &rpc_fxnSigTab,
352             RPC_SKEL_SrvDelNotification);
354     if (status < 0) {
355         System_printf("register_MxServer: MmServiceMgr_register failed, "
356                 "status=%d\n", status);
357         status = -1;
358         goto leave;
359     }
361 leave:
362     System_printf("register_MxServer: <--, status=%d\n", status);