0e0e1192100808a1be88379c0ffea4b737deab29
[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 */
48 #define RPPC_MAX_INST_NAMELEN (48) /* in kernel part of rpmsg_rpc.h */
49 #include </db/vtree/rvh/OMAP5/Depot/ti_linux_3_8/include/linux/rpmsg_rpc.h>
50 // #include <linux/rpmsg_rpc.h>
52 /* this should be in rpmsg_rpc.h, currently in rpmsg_rpc_internal.h */
53 struct rppc_create_instance {
54     char name[RPPC_MAX_INST_NAMELEN];
55 };
57 #include "MmRpc.h"
60 /*
61  *  ======== MmRpc_Object ========
62  */
63 typedef struct {
64     int                         fd;         /* device file descriptor */
65     struct rppc_create_instance connect;    /* connection object */
66 } MmRpc_Object;
68 /*
69  *  ======== MmRpc_Params_init ========
70  */
71 void MmRpc_Params_init(MmRpc_Params *params)
72 {
73     params->reserved = 0;
74 }
76 /*
77  *  ======== MmRpc_create ========
78  */
79 int MmRpc_create(const char *proc, const char *service,
80         const MmRpc_Params *params, MmRpc_Handle *handlePtr)
81 {
82     int             status = MmRpc_S_SUCCESS;
83     MmRpc_Object *  obj;
85     printf("MmRpc_create: -->\n");
87     /* allocate the instance object */
88     obj = (MmRpc_Object *)calloc(1, sizeof(MmRpc_Object));
90     if (obj == NULL) {
91         status = MmRpc_E_FAIL;
92         goto leave;
93     }
95     /* open the driver */
96     printf("MmRpc_create: open driver\n");
97     obj->fd = open("/dev/rpc_example", O_RDWR);
99     if (obj->fd < 0) {
100         printf("MmRpc_create: Error: open failed\n");
101         status = MmRpc_E_FAIL;
102         goto leave;
103     }
105     strncpy(obj->connect.name, "rpc_example", (RPPC_MAX_INST_NAMELEN - 1));
106     obj->connect.name[RPPC_MAX_INST_NAMELEN - 1] = '\0';
108     /* create a server instance, rebind its address to this file descriptor */
109     printf("MmRpc_create: create server instance\n");
110     status = ioctl(obj->fd, RPPC_IOC_CREATE, &obj->connect);
112     if (status < 0) {
113         printf("MmRpc_create: Error: connect failed\n");
114         status = MmRpc_E_FAIL;
115         goto leave;
116     }
118 leave:
119     if (status < 0) {
120         if ((obj != NULL) && (obj->fd >= 0)) {
121             close(obj->fd);
122         }
123         if (obj != NULL) {
124             free(obj);
125         }
126         *handlePtr = NULL;
127     }
128     else {
129         *handlePtr = (MmRpc_Handle)obj;
130     }
132     printf("MmRpc_create: <--\n");
133     return(status);
136 /*
137  *  ======== MmRpc_delete ========
138  */
139 int MmRpc_delete(MmRpc_Handle *handlePtr)
141     int status = MmRpc_S_SUCCESS;
142     MmRpc_Object *obj;
144     printf("MmRpc_delete: -->\n");
145     obj = (MmRpc_Object *)(*handlePtr);
147     /* close the device */
148     if ((obj != NULL) && (obj->fd >= 0)) {
149         close(obj->fd);
150     }
152     /* free the instance object */
153     free((void *)(*handlePtr));
154     *handlePtr = NULL;
156     printf("MmRpc_delete: <--\n");
157     return(status);
160 /*
161  *  ======== MmRpc_call ========
162  */
163 int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret)
165     int status = MmRpc_S_SUCCESS;
166     MmRpc_Object *obj = (MmRpc_Object *)handle;
167     struct rppc_function *rpfxn;
168     struct rppc_function_return reply_msg;
169     void *msg;
170     int len;
171     int i;
173     printf("MmRpc_call: -->\n");
175     /* Combine function parameters and translation array into one contiguous
176      * message. TODO, modify driver to accept two separate buffers in order
177      * to eliminate this step. */
178     len = sizeof(struct rppc_function) +
179                 (ctx->num_translations * sizeof(struct rppc_param_translation));
180     msg = (void *)calloc(len, sizeof(char));
182     if (msg == NULL) {
183         printf("MmRpc_call: Error: msg alloc failed\n");
184         status = MmRpc_E_FAIL;
185         goto leave;
186     }
188     /* copy function arguments into message */
189     rpfxn = (struct rppc_function *)msg;
190     rpfxn->fxn_id = ctx->fxn_id;
191     rpfxn->num_params = ctx->num_params;
193     for (i = 0; i < ctx->num_params; i++) {
194         switch (ctx->params[i].type) {
196             case MmRpc_ParamType_Atomic:
197                 rpfxn->params[i].type = RPPC_PARAM_TYPE_ATOMIC;
198                 rpfxn->params[i].size = ctx->params[i].param.atomic.size;
199                 rpfxn->params[i].data = ctx->params[i].param.atomic.data;
200                 rpfxn->params[i].base = 0;
201                 rpfxn->params[i].reserved = 0;
202                 break;
204             case MmRpc_ParamType_ShMemPtr:
205                 /* TODO */
206                 break;
208             case MmRpc_ParamType_Ptr:
209                 rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
210                 rpfxn->params[i].size = 0;
211                 rpfxn->params[i].data = 0;
212                 rpfxn->params[i].base = 0;
213                 rpfxn->params[i].reserved = 0;
214                 break;
215         }
216     }
218     if (rpfxn->fxn_id == 0x80000002) {
219         printf("MmRpc_call: params[0]=%d\n", rpfxn->params[0].data);
220         printf("MmRpc_call: params[1]=%d\n", rpfxn->params[1].data);
221     }
223     /* copy offset array into message */
224     for (i = 0; i < ctx->num_translations; i++) {
225         rpfxn->translations[i].index    = ctx->translations[i].index;
226         rpfxn->translations[i].offset   = ctx->translations[i].offset;
227         rpfxn->translations[i].base     = ctx->translations[i].base;
228         rpfxn->translations[i].reserved = 0;
229     }
231     /* send message for remote execution */
232     status = write(obj->fd, msg, len);
234     if (status < 0) {
235         printf("MmRpc_call: Error: write failed\n");
236         status = MmRpc_E_FAIL;
237         goto leave;
238     }
240     /* wait for return status from remote service */
241     status = read(obj->fd, &reply_msg, sizeof(struct rppc_function_return));
243     if (status < 0) {
244         printf("MmRpc_call: Error: read failed\n");
245         status = MmRpc_E_FAIL;
246         goto leave;
247     }
248     else if (status != sizeof(struct rppc_function_return)) {
249         printf("MmRpc_call: Error: reply bytes=%d, expected %d\n",
250                 status, sizeof(struct rppc_function_return));
251         status = MmRpc_E_FAIL;
252         goto leave;
253     }
254     else {
255         status = MmRpc_S_SUCCESS;
256     }
258     *ret = (int32_t)reply_msg.status;
260 leave:
261     if (msg != NULL) {
262         free(msg);
263     }
265     printf("MmRpc_call: <-- status=%d\n", status);
266     return(status);