Add MmRpc and mmrpc_test to QNX build.
[ipc/ipcdev.git] / packages / ti / ipc / mm / MmRpc.c
1 /*
2  * Copyright (c) 2012-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.c ========
35  */
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <sys/ioctl.h>
42 #include <fcntl.h>
43 #include <unistd.h>
44 #include <string.h>
46 #include <stdint.h> /* should be in linux/rpmsg_rpc.h */
47 #include <stddef.h> /* should be in linux/rpmsg_rpc.h */
51 #if defined(KERNEL_INSTALL_DIR)
53 #ifdef linux
54 #define _linux_ linux
55 #undef linux
56 #endif
57 #define linux_include(kd,m) <kd/include/linux/m.h>
58 #include linux_include(KERNEL_INSTALL_DIR,rpmsg_rpc)
59 #ifdef _linux_
60 #define linux _linux
61 #undef _linux_
62 #endif
64 #define RPPC_MAX_INST_NAMELEN (48) /* in kernel part of rpmsg_rpc.h */
66 /* this should be in rpmsg_rpc.h, currently in rpmsg_rpc_internal.h */
67 struct rppc_create_instance {
68     char name[RPPC_MAX_INST_NAMELEN];
69 };
71 #elif defined(SYSLINK_BUILDOS_QNX)
73 #include <ti/ipc/rpmsg_rpc.h>
75 #else
76 #error Unsupported Operating System
77 #endif
79 #include "MmRpc.h"
82 /*
83  *  ======== MmRpc_Object ========
84  */
85 typedef struct {
86     int                         fd;         /* device file descriptor */
87     struct rppc_create_instance connect;    /* connection object */
88 } MmRpc_Object;
90 /*
91  *  ======== MmRpc_Params_init ========
92  */
93 void MmRpc_Params_init(MmRpc_Params *params)
94 {
95     params->reserved = 0;
96 }
98 /*
99  *  ======== MmRpc_create ========
100  */
101 int MmRpc_create(const char *proc, const char *service,
102         const MmRpc_Params *params, MmRpc_Handle *handlePtr)
104     int             status = MmRpc_S_SUCCESS;
105     MmRpc_Object *  obj;
107     printf("MmRpc_create: -->\n");
109     /* allocate the instance object */
110     obj = (MmRpc_Object *)calloc(1, sizeof(MmRpc_Object));
112     if (obj == NULL) {
113         status = MmRpc_E_FAIL;
114         goto leave;
115     }
117     /* open the driver */
118     printf("MmRpc_create: open driver\n");
119     obj->fd = open("/dev/rpc_example", O_RDWR);
121     if (obj->fd < 0) {
122         printf("MmRpc_create: Error: open failed\n");
123         status = MmRpc_E_FAIL;
124         goto leave;
125     }
127     strncpy(obj->connect.name, "rpc_example", (RPPC_MAX_INST_NAMELEN - 1));
128     obj->connect.name[RPPC_MAX_INST_NAMELEN - 1] = '\0';
130     /* create a server instance, rebind its address to this file descriptor */
131     printf("MmRpc_create: create server instance\n");
132     status = ioctl(obj->fd, RPPC_IOC_CREATE, &obj->connect);
134     if (status < 0) {
135         printf("MmRpc_create: Error: connect failed\n");
136         status = MmRpc_E_FAIL;
137         goto leave;
138     }
140 leave:
141     if (status < 0) {
142         if ((obj != NULL) && (obj->fd >= 0)) {
143             close(obj->fd);
144         }
145         if (obj != NULL) {
146             free(obj);
147         }
148         *handlePtr = NULL;
149     }
150     else {
151         *handlePtr = (MmRpc_Handle)obj;
152     }
154     printf("MmRpc_create: <--\n");
155     return(status);
158 /*
159  *  ======== MmRpc_delete ========
160  */
161 int MmRpc_delete(MmRpc_Handle *handlePtr)
163     int status = MmRpc_S_SUCCESS;
164     MmRpc_Object *obj;
166     printf("MmRpc_delete: -->\n");
167     obj = (MmRpc_Object *)(*handlePtr);
169     /* close the device */
170     if ((obj != NULL) && (obj->fd >= 0)) {
171         close(obj->fd);
172     }
174     /* free the instance object */
175     free((void *)(*handlePtr));
176     *handlePtr = NULL;
178     printf("MmRpc_delete: <--\n");
179     return(status);
182 /*
183  *  ======== MmRpc_call ========
184  */
185 int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret)
187     int status = MmRpc_S_SUCCESS;
188     MmRpc_Object *obj = (MmRpc_Object *)handle;
189     struct rppc_function *rpfxn;
190     struct rppc_function_return reply_msg;
191     MmRpc_Param *arg;
192     void *msg;
193     int len;
194     int i;
196     printf("MmRpc_call: -->\n");
198     /* Combine function parameters and translation array into one contiguous
199      * message. TODO, modify driver to accept two separate buffers in order
200      * to eliminate this step. */
201     len = sizeof(struct rppc_function) +
202                 (ctx->num_translations * sizeof(struct rppc_param_translation));
203     msg = (void *)calloc(len, sizeof(char));
205     if (msg == NULL) {
206         printf("MmRpc_call: Error: msg alloc failed\n");
207         status = MmRpc_E_FAIL;
208         goto leave;
209     }
211     /* copy function arguments into message */
212     rpfxn = (struct rppc_function *)msg;
213     rpfxn->fxn_id = ctx->fxn_id;
214     rpfxn->num_params = ctx->num_params;
216     for (i = 0; i < ctx->num_params; i++) {
217         arg = &ctx->params[i];
219         switch (arg->type) {
220             case MmRpc_ParamType_Atomic:
221                 rpfxn->params[i].type = RPPC_PARAM_TYPE_ATOMIC;
222                 rpfxn->params[i].size = arg->param.atomic.size;
223                 rpfxn->params[i].data = arg->param.atomic.data;
224                 rpfxn->params[i].base = 0;
225                 rpfxn->params[i].reserved = 0;
226                 break;
228             case MmRpc_ParamType_Ptr:
229                 rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
230                 rpfxn->params[i].size = arg->param.ptr.size;
231                 rpfxn->params[i].data = arg->param.ptr.addr;
232                 rpfxn->params[i].base = arg->param.ptr.addr;
233                 rpfxn->params[i].reserved = arg->param.ptr.handle;
234                 break;
236             case MmRpc_ParamType_PtrOffset:
237                 rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
238                 rpfxn->params[i].size = arg->param.ptrOffset.size;
239                 rpfxn->params[i].data = arg->param.ptrOffset.offset;
240                 rpfxn->params[i].base = arg->param.ptrOffset.base;
241                 rpfxn->params[i].reserved = arg->param.ptrOffset.handle;
242                 break;
243         }
244     }
246     /* copy offset array into message */
247     for (i = 0; i < ctx->num_translations; i++) {
248         rpfxn->translations[i].index    = ctx->translations[i].index;
249         rpfxn->translations[i].offset   = ctx->translations[i].offset;
250         rpfxn->translations[i].base     = ctx->translations[i].base;
251         rpfxn->translations[i].reserved = 0;
252     }
254     /* send message for remote execution */
255     status = write(obj->fd, msg, len);
257     if (status < 0) {
258         printf("MmRpc_call: Error: write failed\n");
259         status = MmRpc_E_FAIL;
260         goto leave;
261     }
263     /* wait for return status from remote service */
264     status = read(obj->fd, &reply_msg, sizeof(struct rppc_function_return));
266     if (status < 0) {
267         printf("MmRpc_call: Error: read failed\n");
268         status = MmRpc_E_FAIL;
269         goto leave;
270     }
271     else if (status != sizeof(struct rppc_function_return)) {
272         printf("MmRpc_call: Error: reply bytes=%d, expected %d\n",
273                 status, sizeof(struct rppc_function_return));
274         status = MmRpc_E_FAIL;
275         goto leave;
276     }
277     else {
278         status = MmRpc_S_SUCCESS;
279     }
281     *ret = (int32_t)reply_msg.status;
283 leave:
284     if (msg != NULL) {
285         free(msg);
286     }
288     printf("MmRpc_call: <-- status=%d\n", status);
289     return(status);