a34144d28db2d2a96fe9aa1bfa05f832417db3f6
[ipc/ipcdev.git] / qnx / src / tests / GateMPApp / GateMPApp.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  *  ======== GateMPApp.c ========
35  *
36  */
38 /* host header files */
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <unistd.h>
43 /* package header files */
44 #include <ti/ipc/Std.h>
45 #include <ti/ipc/MessageQ.h>
46 #include <ti/ipc/GateMP.h>
48 /* local header files */
49 #include "GateMPApp.h"
51 #include <ti/shmemallocator/SharedMemoryAllocatorUsr.h>
52 #include <ti/ipc/tests/GateMPAppCommon.h>
54 /* module structure */
55 typedef struct {
56     MessageQ_Handle       hostQue;    /* created locally */
57     MessageQ_QueueId      slaveQue;   /* opened remotely */
58     UInt16                heapId;     /* MessageQ heapId */
59     UInt32                msgSize;    /* Size of messages */
60     volatile UInt32 *     intPtr;     /* Integer pointer */
61     UInt32                physAddr;   /* Physical address of shared memory */
62     GateMP_Handle         hostGateMPHandle;  /* handle to host-created gate */
63     GateMP_Handle         slaveGateMPHandle; /* handle to slave-created gate */
64     shm_buf               buf;        /* shared memory buffer */
65 } GateMPApp_Module;
67 /* private data */
68 static GateMPApp_Module Module;
71 /*
72  *  ======== GateMPApp_create ========
73  */
75 Int GateMPApp_create()
76 {
77     Int                 status    =0;
78     MessageQ_Params     msgqParams;
79     GateMP_Params       gateParams;
81     printf("--> GateMPApp_create:\n");
83     /* setting default values */
84     Module.hostQue = NULL;
85     Module.slaveQue = MessageQ_INVALIDMESSAGEQ;
86     Module.heapId = GateMPApp_MsgHeapId;
87     Module.intPtr = NULL;
88     Module.physAddr = 0;
89     Module.hostGateMPHandle = NULL;
90     Module.slaveGateMPHandle = NULL;
91     Module.msgSize = sizeof(GateMPApp_Msg);
93     /* create local message queue (inbound messages) */
94     MessageQ_Params_init(&msgqParams);
96     Module.hostQue = MessageQ_create(GateMPApp_HostMsgQueName, &msgqParams);
98     if (Module.hostQue == NULL) {
99         printf("GateMPApp_create: Failed creating MessageQ\n");
100         status = GATEMPAPP_E_FAILURE;
101         goto leave;
102     }
104     /* open the remote message queue */
105     do {
106         status = MessageQ_open(GateMPApp_SlaveMsgQueName, &Module.slaveQue);
107         sleep(1);
108     } while (status == MessageQ_E_NOTFOUND);
110     if (status < 0) {
111         printf("GateMPApp_create: Failed opening MessageQ\n");
112         status = GATEMPAPP_E_FAILURE;
113         goto leave;
114     }
116     /* allocate space from shared memory for an integer */
117     status = SHM_alloc_aligned(sizeof(UInt32), sizeof(UInt32), &Module.buf);
118     if (status < 0) {
119         printf("GateMPApp_create: Could not allocate shared memory\n");
120         status = GATEMPAPP_E_FAILURE;
121         goto leave;
122     }
123     Module.intPtr = (UInt32 *)Module.buf.vir_addr;
124     Module.physAddr = (UInt32)Module.buf.phy_addr;
126     if ((Module.intPtr == NULL) || (Module.physAddr == NULL)) {
127         printf("GateMPApp_create: Failed to get buffer address\n");
128         status = GATEMPAPP_E_FAILURE;
129         goto leave;
130     }
132     /* create GateMP */
133     GateMP_Params_init(&gateParams);
135     gateParams.name             = GATEMP_HOST_NAME;
136     gateParams.localProtect     = GateMP_LocalProtect_PROCESS;
137     gateParams.remoteProtect    = GateMP_RemoteProtect_SYSTEM;
139     Module.hostGateMPHandle = GateMP_create (&gateParams);
141     if (Module.hostGateMPHandle == NULL) {
142         status = GATEMPAPP_E_FAILURE;
143         printf("GateMPApp_create: Failed to create GateMP\n");
144         goto leave;
145     }
146     printf("GateMPApp_create: Host is ready\n");
148 leave:
149     printf("<-- GateMPApp_create:\n");
150     return(status);
154 /*
155  *  ======== GateMPApp_delete ========
156  */
157 Int GateMPApp_delete(Void)
159     Int         status;
160     GateMPApp_Msg *   msg;
162     printf("--> GateMPApp_delete:\n");
164     /* allocate message */
165     msg = (GateMPApp_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
167     if (msg == NULL) {
168         status = GATEMPAPP_E_FAILURE;
169         goto leave;
170     }
172     /* set the return address in the message header */
173     MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);
175     /* sending shutdown command */
176     msg->cmd = GATEMPAPP_CMD_SHUTDOWN;
177     MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
179     /* wait for acknowledgement message */
180     status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
181             MessageQ_FOREVER);
183     if (status < 0) {
184         status = GATEMPAPP_E_FAILURE;
185         goto leave;
186     }
188     if (msg->cmd != GATEMPAPP_CMD_SHUTDOWN_ACK) {
189         status = GATEMPAPP_E_UNEXPECTEDMSG;
190         goto leave;
191     }
193     /* free the message */
194     MessageQ_free((MessageQ_Msg)msg);
196     /* delete GateMP */
197     GateMP_delete(&Module.hostGateMPHandle);
199     /* free shared memory buffer */
200     status = SHM_release(&Module.buf);
201     if(status < 0) {
202         status = GATEMPAPP_E_FAILURE;
203         goto leave;
204     }
206     /* close remote resources */
207     status = MessageQ_close(&Module.slaveQue);
209     if (status < 0) {
210         status = GATEMPAPP_E_FAILURE;
211         goto leave;
212     }
214     /* delete the host message queue */
215     status = MessageQ_delete(&Module.hostQue);
217     if (status < 0) {
218         status = GATEMPAPP_E_FAILURE;
219         goto leave;
220     }
222 leave:
223     printf("<-- GateMPApp_delete:\n");
224     return(status);
228 /*
229  *  ======== GateMPApp_exec ========
230  */
231 Int GateMPApp_exec(Void)
233     Int         status;
234     Int         i;
235     GateMPApp_Msg *   msg;
236     IArg        gateKey         = 0;
237     UInt32      num;
239     printf("--> GateMPApp_exec:\n");
241     /* set shared variable initial value */
242     *Module.intPtr = 500;
244     /* allocate message */
245     msg = (GateMPApp_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
246     if (msg == NULL) {
247         status = GATEMPAPP_E_FAILURE;
248         goto leave;
249     }
251     /* set the return address in the message header */
252     MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);
254     /* fill in message payload */
255     msg->cmd = GATEMPAPP_CMD_SPTR_ADDR;
256     msg->payload = Module.physAddr;
258     /* send message */
259     MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
261     /* wait for return message */
262     status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
263         MessageQ_FOREVER);
264     if (status < 0) {
265         goto leave;
266     }
268     if (msg->cmd != GATEMPAPP_CMD_SPTR_ADDR_ACK)
269     {
270         status = GATEMPAPP_E_UNEXPECTEDMSG;
271         goto leave;
272     }
274     /* free the message */
275     MessageQ_free((MessageQ_Msg)msg);
277     /* open slave-created GateMP */
278     do {
279         status = GateMP_open(GATEMP_SLAVE_NAME, &Module.slaveGateMPHandle);
280     } while (status == GateMP_E_NOTFOUND);
282     if (status < 0) {
283         printf("GateMPApp_exec: Failed to open slave-created GateMP");
284         status = GATEMPAPP_E_FAILURE;
285         goto leave;
286     }
288     printf("GateMPApp_exec: Using host-created gate\n");
289     for (i = 0; i < LOOP_ITR; i++) {
290         /* read the shared variable as long as no one is currently modifying
291          * it
292          */
294         /* enter GateMP */
295         gateKey = GateMP_enter(Module.hostGateMPHandle);
297         /* randomly modify the shared variable */
298         if (rand() % 2) {
299             *Module.intPtr -= 1;
300         }
301         else {
302             *Module.intPtr += 1;
303         }
305         /* read shared variable value */
306         num = *Module.intPtr;
307         printf("GateMPApp_exec: Current value: %d, " \
308             "previously read=%d\n", *Module.intPtr, num);
310         if (*Module.intPtr != num) {
311             printf("GateMPApp_exec: mismatch in variable value." \
312                 "Test failed.\n");
313             status = GATEMPAPP_E_FAILURE;
314             goto leave;
315         }
317         /* exit GateMP */
318         GateMP_leave(Module.hostGateMPHandle, gateKey);
319     }
321     /* allocate message */
322     msg = (GateMPApp_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
323     if (msg == NULL) {
324         status = GATEMPAPP_E_FAILURE;
325         goto leave;
326     }
328     /* set the return address in the message header */
329     MessageQ_setReplyQueue(Module.hostQue, (MessageQ_Msg)msg);
331     /* fill in message payload */
332     msg->cmd = GATEMPAPP_CMD_SYNC;
334     /* send sync message */
335     MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
337     /* wait for return sync message before we switch gates */
338     status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
339         MessageQ_FOREVER);
340     if (status < 0) {
341         goto leave;
342     }
344     if (msg->cmd != GATEMPAPP_CMD_SYNC)
345     {
346         status = GATEMPAPP_E_UNEXPECTEDMSG;
347         goto leave;
348     }
350     /* free the message */
351     MessageQ_free((MessageQ_Msg)msg);
353     printf("GateMPApp_exec: Using slave-created gate\n");
354     for (i = 0; i < LOOP_ITR; i++) {
355         /* read the shared variable as long as no one is currently modifying
356          * it
357          */
359         /* enter GateMP */
360         gateKey = GateMP_enter(Module.slaveGateMPHandle);
362         /* randomly modify the shared variable */
363         if (rand() % 2) {
364             *Module.intPtr -= 1;
365         }
366         else {
367             *Module.intPtr += 1;
368         }
370         /* read shared variable value */
371         num = *Module.intPtr;
372         printf("GateMPApp_exec: Current value: %d, " \
373             "previously read=%d\n", *Module.intPtr, num);
375         if (*Module.intPtr != num) {
376             printf("GateMPApp_exec: mismatch in variable value." \
377                 "Test failed.\n");
378             status = GATEMPAPP_E_FAILURE;
379             goto leave;
380         }
382         /* exit GateMP */
383         GateMP_leave(Module.slaveGateMPHandle, gateKey);
384     }
386 leave:
387     if (Module.slaveGateMPHandle) {
388         GateMP_close(&Module.slaveGateMPHandle);
389     }
391     printf("<-- GateMPApp_exec: %d\n", status);
392     return(status);