Support in QNX MmRpc/MmServiceMgr to identify deleted instance during cleanup
[ipc/ipcdev.git] / packages / ti / ipc / tests / rpc_task.c
1 /*
2  * Copyright (c) 2013-2014, 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(Uint32 id)
151     System_printf("RPC_SKEL_SrvDelNotification: Nothing to cleanup for "
152         "MmRpc instance id=%d\n", id);
155 static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data)
157     System_printf("RPC_SKEL_Init2: size=0x%x data=0x%x\n", size, data);
158     return(0);
161 /*
162  *  ======== MxServer_skel_triple ========
163  */
164 Int32 MxServer_skel_triple(UInt32 size, UInt32 *data)
166     MmType_Param *payload = (MmType_Param *)data;
167     UInt32 a;
168     Int32 result;
170     a = (UInt32)payload[0].data;
171     result = MxServer_triple(a);
173 #if CHATTER
174     System_printf("fxnTriple: a=%d, result=%d\n", a, result);
175 #endif
177     return(result);
180 /*
181  *  ======== MxServer_skel_add ========
182  */
183 Int32 MxServer_skel_add(UInt32 size, UInt32 *data)
185     MmType_Param *payload = (MmType_Param *)data;
186     Int32 a, b;
187     Int32 result;
189     a = (Int32)payload[0].data;
190     b = (Int32)payload[1].data;
192     result = MxServer_add(a, b);
194 #if CHATTER
195     System_printf("fxnAdd: a=%d, b=%d, result=%d\n", a, b, result);
196 #endif
198     return(result);
201 /*
202  *  ======== fxnAdd3 ========
203  */
204 Int32 fxnAdd3(UInt32 size, UInt32 *data)
206     MmType_Param *payload = (MmType_Param *)data;
207     FxnAdd3Args *args;
208     Int a, b, c;
210     args = (FxnAdd3Args *)payload[0].data;
212     Cache_inv (args, sizeof(FxnAdd3Args), Cache_Type_ALL, TRUE);
214     a = args->a;
215     b = args->b;
216     c = args->c;
218 #if CHATTER
219     System_printf("fxnAdd3: a=%d, b=%d, c=%d\n", a, b, c);
220 #endif
222     return(a + b + c);
225 /*
226  *  ======== fxnAddX ========
227  */
228 Int32 fxnAddX(UInt32 size, UInt32 *data)
230     MmType_Param *payload = (MmType_Param *)data;
231     FxnAddXArgs *args;
232     Int num, i, sum = 0;
233     Int *array;
235     args = (FxnAddXArgs *)payload[0].data;
237     Cache_inv (args, sizeof(FxnAddXArgs), Cache_Type_ALL, TRUE);
239     num = args->num;
240     array = args->array;
242     Cache_inv (array, sizeof(Int) * num, Cache_Type_ALL, TRUE);
244 #if CHATTER
245     System_printf("fxnAddX: ");
246 #endif
247     for (i = 0; i < num; i++) {
248 #if CHATTER
249         System_printf(" a[%d]=%d,", i, array[i]);
250 #endif
251         sum += array[i];
252     }
254 #if CHATTER
255     System_printf(" sum=%d\n", sum);
256 #endif
258     return(sum);
261 /*
262  *  ======== MxServer_skel_compute ========
263  */
264 Int32 MxServer_skel_compute(UInt32 size, UInt32 *data)
266     MmType_Param *payload;
267     MxServer_Compute *compute;
268     Int32 result = 0;
270     payload = (MmType_Param *)data;
271     compute = (MxServer_Compute *)payload[0].data;
273     Cache_inv(compute, sizeof(MxServer_Compute), Cache_Type_ALL, TRUE);
275 #if CHATTER
276     System_printf("skel_compute: compute=0x%x\n", compute);
277     System_printf("skel_compute: compute size=%d\n", (Int)payload[0].size);
278     System_printf("skel_compute: coef=0x%x\n", compute->coef);
279     System_printf("skel_compute: key=0x%x\n", compute->key);
280     System_printf("skel_compute: size=0x%x\n", compute->size);
281     System_printf("skel_compute: inBuf=0x%x\n", compute->inBuf);
282     System_printf("skel_compute: outBuf=0x%x\n", compute->outBuf);
283 #endif
285     Cache_inv(compute->inBuf, compute->size * sizeof(uint32_t),
286             Cache_Type_ALL, TRUE);
287     Cache_inv(compute->outBuf, compute->size * sizeof(uint32_t),
288             Cache_Type_ALL, TRUE);
290 #if CHATTER
291     System_printf("skel_compute: outBuf[0]=0x%x\n", compute->outBuf[0]);
292     System_printf("skel_compute: inBuf[0]=0x%x\n", compute->inBuf[0]);
293 #endif
295     /* invoke the implementation function */
296     result = MxServer_compute(compute);
298     Cache_wbInv(compute->outBuf, compute->size * sizeof(uint32_t),
299             Cache_Type_ALL, TRUE);
301     return(result);
304 /*
305  *  ======== fxnAddX ========
306  */
307 Int32 fxnFault(UInt32 size, UInt32 *data)
309     MmType_Param *payload = (MmType_Param *)data;
310     Int a;
311     typedef Int (*MyCode)();
312     MyCode fxn = (MyCode)0x96000000;
313     volatile Int dummy = 0;
315     a = (UInt32)payload[0].data;
317     switch (a) {
318         case 1:
319             System_printf("Generating read MMU Fault...\n");
320             a = *(volatile int *)(0x96000000);
321             break;
322         case 2:
323             System_printf("Generating write MMU Fault...\n");
324             *(volatile int *)(0x96000000) = 0x1;
325             break;
326         case 3:
327             System_printf("Generating program MMU Fault...\n");
328             fxn();
329             break;
330         case 4:
331             System_printf("Generating exception...\n");
332             dummy = dummy / dummy;
333             break;
334         case 5:
335             System_printf("Generating Watchdog interrupt...\n");
336             dummy = 1;
337             while(dummy);
338             break;
339         default:
340             System_printf("Invalid fxnFault test\n");
341             break;
342     }
344     return(0);
347 /*
348  *  ======== register_MxServer ========
349  *
350  *  Bootstrap function, must be configured in BIOS.addUserStartupFunctions.
351  */
352 void register_MxServer(void)
354     Int status = MmServiceMgr_S_SUCCESS;
355     Char mMServerName[20];
357     System_printf("register_MxServer: -->\n");
359     /* must initialize these modules before using them */
360     RcmServer_init();
361     MmServiceMgr_init();
363     /* setup the server create params */
364     RcmServer_Params_init(&rpc_Params);
365     rpc_Params.priority = Thread_Priority_ABOVE_NORMAL;
366     rpc_Params.stackSize = 0x1000;
367     rpc_Params.fxns.length = rpc_fxnTab.length;
368     rpc_Params.fxns.elem = rpc_fxnTab.elem;
370     /* Construct an MMServiceMgr name adorned with core name: */
371     System_sprintf(mMServerName, "%s_%d", SERVICE_NAME,
372                    MultiProc_self());
374     /* register an example service */
375     status = MmServiceMgr_register2(mMServerName, &rpc_Params, &rpc_fxnSigTab,
376             RPC_SKEL_SrvDelNotification);
378     if (status < 0) {
379         System_printf("register_MxServer: MmServiceMgr_register failed, "
380                 "status=%d\n", status);
381         status = -1;
382         goto leave;
383     }
385 leave:
386     System_printf("register_MxServer: <--, status=%d\n", status);