Final merge of Suman and Angela's latest updates. Updates to MmRpc.
authorRamsey Harris <ramsey@ti.com>
Mon, 18 Mar 2013 17:18:05 +0000 (10:18 -0700)
committerRamsey Harris <ramsey@ti.com>
Mon, 18 Mar 2013 17:45:20 +0000 (10:45 -0700)
The MmRpc module is now functional for remote function calls using
atomic parameters. Updated mmrpc_test to invoke fxnTriple and fxnAdd
remote functions.

12 files changed:
linux/src/tests/mmrpc_test.c
packages/ti/grcm/RcmTypes.h
packages/ti/ipc/mm/MmRpc.c
packages/ti/ipc/mm/MmRpc.h
packages/ti/ipc/tests/rpc_task.c
packages/ti/ipc/tests/test_omx.c
packages/ti/ipc/tests/test_omx_ipu_omap5.cfg
packages/ti/srvmgr/ServiceMgr.c
packages/ti/srvmgr/omaprpc/OmapRpc.c
packages/ti/srvmgr/omaprpc/OmapRpc.h
packages/ti/srvmgr/omaprpc/package.bld
packages/ti/srvmgr/rpmsg_omx.h

index 0359382c5f0dfab823d9e0606f5475fe562362a4..b101c62debfcb633c7f50c52691e41eb496b8a3b 100644 (file)
 
 #include <ti/ipc/mm/MmRpc.h>
 
+
+/* module 'Mx' functions */
+int Mx_initialize(void);
+void Mx_finalize(void);
+
+int32_t Mx_triple(uint32_t a);
+int32_t Mx_add(int32_t a, int32_t b);
+
+MmRpc_Handle Mx_rpcDsp = NULL;
+
+/* static function indicies */
+#define Mx_Fxn_triple   (0x80000000 | 1)
+#define Mx_Fxn_add      (0x80000000 | 2)
+
+
+/*
+ *  ======== main ========
+ */
 int main(int argc, char **argv)
 {
-    MmRpc_Params params;
-    MmRpc_Handle dsp_rpc;
+    int status;
+    int32_t ret;
 
-    printf("Hello world\n");
+    printf("mmrpc_test: --> main\n");
 
-    MmRpc_Params_init(&params);
+    /* initialize Mx module (setup rpc connection) */
+    status = Mx_initialize();
+
+    if (status < 0) {
+        goto leave;
+    }
+
+    /* invoke Mx functions */
+    ret = Mx_triple(11);
+    printf("mmrpc_test: Mx_triple(11), ret=%d\n", ret);
+
+    if (ret < 0) {
+        status = -1;
+        goto leave;
+    }
 
-    dsp_rpc  = MmRpc_create("DSP", "FooServer", &params);
+    ret = Mx_triple(111);
+    printf("mmrpc_test: Mx_triple(111), ret=%d\n", ret);
 
-    MmRpc_delete(&dsp_rpc);
+    if (ret < 0) {
+        status = -1;
+        goto leave;
+    }
 
+    ret = Mx_add(44, 66);
+    printf("mmrpc_test: Mx_add(44, 66), ret=%d\n", ret);
+
+    if (ret < 0) {
+        status = -1;
+        goto leave;
+    }
+
+leave:
+    /* finalize Mx module (destroy rpc connection) */
+    Mx_finalize();
+
+    if (status < 0) {
+        printf("mmrpc_test: FAILED\n");
+    }
+    else {
+        printf("mmrpc_test: PASSED\n");
+    }
     return(0);
 }
+
+/*
+ *  ======== Mx_initialize ========
+ */
+int Mx_initialize(void)
+{
+    int status;
+    MmRpc_Params params;
+
+    /* create remote server insance */
+    MmRpc_Params_init(&params);
+
+    status = MmRpc_create("DSP", "FooServer", &params, &Mx_rpcDsp);
+
+    if (status < 0) {
+        printf("mmrpc_test: Error: MmRpc_create failed\n");
+        status = -1;
+    }
+    else {
+        status = 0;
+    }
+
+    return(status);
+}
+
+/*
+ *  ======== Mx_finalize ========
+ */
+void Mx_finalize(void)
+{
+    /* delete remote server instance */
+    if (Mx_rpcDsp != NULL) {
+        MmRpc_delete(&Mx_rpcDsp);
+    }
+}
+
+/*
+ *  ======== Mx_triple ========
+ */
+int32_t Mx_triple(uint32_t a)
+{
+    MmRpc_FxnCtx *fxnCtx;
+    int32_t fxnRet;
+    char send_buf[512] = {0};
+    int status;
+
+    /* marshall function arguments into the send buffer */
+    fxnCtx = (MmRpc_FxnCtx *)send_buf;
+
+    fxnCtx->fxn_id = Mx_Fxn_triple;
+    fxnCtx->num_params = 1;
+    fxnCtx->params[0].type = MmRpc_ParamType_Atomic;
+    fxnCtx->params[0].param.atomic.size = sizeof(int);
+    fxnCtx->params[0].param.atomic.data = a;
+    fxnCtx->num_translations = 0;
+
+    /* invoke the remote function call */
+    status = MmRpc_call(Mx_rpcDsp, fxnCtx, &fxnRet);
+
+    if (status < 0) {
+        printf("mmrpc_test: Error: MmRpc_call failed\n");
+        fxnRet = -1;
+    }
+
+    return(fxnRet);
+}
+
+/*
+ *  ======== Mx_add ========
+ */
+int32_t Mx_add(int32_t a, int32_t b)
+{
+    MmRpc_FxnCtx *fxnCtx;
+    int32_t fxnRet;
+    char send_buf[512] = {0};
+    int status;
+
+    /* marshall function arguments into the send buffer */
+    fxnCtx = (MmRpc_FxnCtx *)send_buf;
+
+    fxnCtx->fxn_id = Mx_Fxn_add;
+    fxnCtx->num_params = 2;
+    fxnCtx->params[0].type = MmRpc_ParamType_Atomic;
+    fxnCtx->params[0].param.atomic.size = sizeof(int);
+    fxnCtx->params[0].param.atomic.data = a;
+    fxnCtx->params[1].type = MmRpc_ParamType_Atomic;
+    fxnCtx->params[1].param.atomic.size = sizeof(int);
+    fxnCtx->params[1].param.atomic.data = b;
+    fxnCtx->num_translations = 0;
+
+    /* invoke the remote function call */
+    status = MmRpc_call(Mx_rpcDsp, fxnCtx, &fxnRet);
+
+    if (status < 0) {
+        printf("mmrpc_test: Error: MmRpc_call failed\n");
+        fxnRet = -1;
+    }
+
+    return(fxnRet);
+}
index 523e63a33942a53eea82e0ddc1f6de711ab16eb8..bd342780a20db3826ba245124b6878614e61f007 100644 (file)
 /* Need to deal with this structure, as Linux side rpmsg_omx driver needs it: */
 struct rpmsg_omx_hdr {
     UInt32 type;
-    UInt32 flags;
     UInt32 len;
 };
 
index 12d2425cc4204360a25e4ccf60a8dd8aa3612669..0e0e1192100808a1be88379c0ffea4b737deab29 100644 (file)
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/ioctl.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <string.h>
+
+#include <stdint.h> /* should be in linux/rpmsg_rpc.h */
+#include <stddef.h> /* should be in linux/rpmsg_rpc.h */
+#define RPPC_MAX_INST_NAMELEN (48) /* in kernel part of rpmsg_rpc.h */
+#include </db/vtree/rvh/OMAP5/Depot/ti_linux_3_8/include/linux/rpmsg_rpc.h>
+// #include <linux/rpmsg_rpc.h>
+
+/* this should be in rpmsg_rpc.h, currently in rpmsg_rpc_internal.h */
+struct rppc_create_instance {
+    char name[RPPC_MAX_INST_NAMELEN];
+};
 
 #include "MmRpc.h"
 
+
 /*
  *  ======== MmRpc_Object ========
  */
 typedef struct {
-    int         fd;             /* device file descriptor */
+    int                         fd;         /* device file descriptor */
+    struct rppc_create_instance connect;    /* connection object */
 } MmRpc_Object;
 
 /*
@@ -61,11 +76,11 @@ void MmRpc_Params_init(MmRpc_Params *params)
 /*
  *  ======== MmRpc_create ========
  */
-MmRpc_Handle MmRpc_create(const char *proc, const char *service,
-        const MmRpc_Params *params)
+int MmRpc_create(const char *proc, const char *service,
+        const MmRpc_Params *params, MmRpc_Handle *handlePtr)
 {
-    int                 status = MmRpc_S_SUCCESS;
-    MmRpc_Object *      obj;
+    int             status = MmRpc_S_SUCCESS;
+    MmRpc_Object *  obj;
 
     printf("MmRpc_create: -->\n");
 
@@ -78,6 +93,7 @@ MmRpc_Handle MmRpc_create(const char *proc, const char *service,
     }
 
     /* open the driver */
+    printf("MmRpc_create: open driver\n");
     obj->fd = open("/dev/rpc_example", O_RDWR);
 
     if (obj->fd < 0) {
@@ -86,6 +102,19 @@ MmRpc_Handle MmRpc_create(const char *proc, const char *service,
         goto leave;
     }
 
+    strncpy(obj->connect.name, "rpc_example", (RPPC_MAX_INST_NAMELEN - 1));
+    obj->connect.name[RPPC_MAX_INST_NAMELEN - 1] = '\0';
+
+    /* create a server instance, rebind its address to this file descriptor */
+    printf("MmRpc_create: create server instance\n");
+    status = ioctl(obj->fd, RPPC_IOC_CREATE, &obj->connect);
+
+    if (status < 0) {
+        printf("MmRpc_create: Error: connect failed\n");
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+
 leave:
     if (status < 0) {
         if ((obj != NULL) && (obj->fd >= 0)) {
@@ -94,10 +123,14 @@ leave:
         if (obj != NULL) {
             free(obj);
         }
+        *handlePtr = NULL;
+    }
+    else {
+        *handlePtr = (MmRpc_Handle)obj;
     }
 
     printf("MmRpc_create: <--\n");
-    return((MmRpc_Handle)obj);
+    return(status);
 }
 
 /*
@@ -123,3 +156,112 @@ int MmRpc_delete(MmRpc_Handle *handlePtr)
     printf("MmRpc_delete: <--\n");
     return(status);
 }
+
+/*
+ *  ======== MmRpc_call ========
+ */
+int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret)
+{
+    int status = MmRpc_S_SUCCESS;
+    MmRpc_Object *obj = (MmRpc_Object *)handle;
+    struct rppc_function *rpfxn;
+    struct rppc_function_return reply_msg;
+    void *msg;
+    int len;
+    int i;
+
+    printf("MmRpc_call: -->\n");
+
+    /* Combine function parameters and translation array into one contiguous
+     * message. TODO, modify driver to accept two separate buffers in order
+     * to eliminate this step. */
+    len = sizeof(struct rppc_function) +
+                (ctx->num_translations * sizeof(struct rppc_param_translation));
+    msg = (void *)calloc(len, sizeof(char));
+
+    if (msg == NULL) {
+        printf("MmRpc_call: Error: msg alloc failed\n");
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+
+    /* copy function arguments into message */
+    rpfxn = (struct rppc_function *)msg;
+    rpfxn->fxn_id = ctx->fxn_id;
+    rpfxn->num_params = ctx->num_params;
+
+    for (i = 0; i < ctx->num_params; i++) {
+        switch (ctx->params[i].type) {
+
+            case MmRpc_ParamType_Atomic:
+                rpfxn->params[i].type = RPPC_PARAM_TYPE_ATOMIC;
+                rpfxn->params[i].size = ctx->params[i].param.atomic.size;
+                rpfxn->params[i].data = ctx->params[i].param.atomic.data;
+                rpfxn->params[i].base = 0;
+                rpfxn->params[i].reserved = 0;
+                break;
+
+            case MmRpc_ParamType_ShMemPtr:
+                /* TODO */
+                break;
+
+            case MmRpc_ParamType_Ptr:
+                rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
+                rpfxn->params[i].size = 0;
+                rpfxn->params[i].data = 0;
+                rpfxn->params[i].base = 0;
+                rpfxn->params[i].reserved = 0;
+                break;
+        }
+    }
+
+    if (rpfxn->fxn_id == 0x80000002) {
+        printf("MmRpc_call: params[0]=%d\n", rpfxn->params[0].data);
+        printf("MmRpc_call: params[1]=%d\n", rpfxn->params[1].data);
+    }
+
+    /* copy offset array into message */
+    for (i = 0; i < ctx->num_translations; i++) {
+        rpfxn->translations[i].index    = ctx->translations[i].index;
+        rpfxn->translations[i].offset   = ctx->translations[i].offset;
+        rpfxn->translations[i].base     = ctx->translations[i].base;
+        rpfxn->translations[i].reserved = 0;
+    }
+
+    /* send message for remote execution */
+    status = write(obj->fd, msg, len);
+
+    if (status < 0) {
+        printf("MmRpc_call: Error: write failed\n");
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+
+    /* wait for return status from remote service */
+    status = read(obj->fd, &reply_msg, sizeof(struct rppc_function_return));
+
+    if (status < 0) {
+        printf("MmRpc_call: Error: read failed\n");
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+    else if (status != sizeof(struct rppc_function_return)) {
+        printf("MmRpc_call: Error: reply bytes=%d, expected %d\n",
+                status, sizeof(struct rppc_function_return));
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+    else {
+        status = MmRpc_S_SUCCESS;
+    }
+
+    *ret = (int32_t)reply_msg.status;
+
+leave:
+    if (msg != NULL) {
+        free(msg);
+    }
+
+    printf("MmRpc_call: <-- status=%d\n", status);
+    return(status);
+}
index 04fabe657e3444edc5fa0f1a9f25a029ddb85373..996a88f9dc5bb8752704d61488478a7db3f9c8e6 100644 (file)
@@ -88,6 +88,7 @@ typedef enum {
  */
 typedef struct {
     MmRpc_ParamType     type;   /*!< parameter type */
+
     union {
         struct {
             size_t      size;   /*!< size of the data */
@@ -119,7 +120,6 @@ typedef struct {
  */
 typedef struct {
     uint32_t    fxn_id;         /*!< The function to call. */
-    uint32_t    result;         /*!< The function return value. */
     uint32_t    num_params;     /*!< Number of elements in param array. */
     MmRpc_Param params[MmRpc_MAX_PARAMETERS];
                                 /*!< The array of parameters */
@@ -140,14 +140,14 @@ typedef struct {
  *  @brief      Invoke a remote procedure call
  *
  */
-int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx);
+int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret);
 
 /*!
  *  @brief      Create an MmRpc instance
  *
  */
-MmRpc_Handle MmRpc_create(const char *proc, const char *service,
-        const MmRpc_Params *params);
+int MmRpc_create(const char *proc, const char *service,
+        const MmRpc_Params *params, MmRpc_Handle *handlPtr);
 
 /*!
  *  @brief      Delete an MmRpc instance
index ad8ab1233b4277a58dae8504ffeee3b36f19f054..8cfdc1a76eaf10e65f991055874e5dd7f8509d99 100644 (file)
@@ -59,7 +59,7 @@
 #include <ti/srvmgr/omx_packet.h>
 
 /* Turn on/off printf's */
-#define CHATTER 0
+#define CHATTER 1
 
 #define RPC_MGR_PORT    59
 
@@ -83,9 +83,17 @@ typedef enum {
  *  ======== fxnTriple used by omx_benchmark test app ========
  */
 typedef struct {
+    Int size_a;
     Int a;
 } FxnTripleArgs;
 
+typedef struct {
+    Int size_a;
+    Int a;
+    Int size_b;
+    Int b;
+} FxnAddArgs;
+
 #define H264_DECODER_NAME   "H264_decoder"
 
 #define OMX_VIDEO_THREAD_PRIORITY    5
@@ -97,6 +105,7 @@ static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data);
 static Int32 RPC_SKEL_SetParameter(UInt32 size, UInt32 *data);
 static Int32 RPC_SKEL_GetParameter(UInt32 size, UInt32 *data);
 static Int32 fxnTriple(UInt32 size, UInt32 *data);
+static Int32 fxnAdd(UInt32 size, UInt32 *data);
 
 #if 0
 /* RcmServer static function table */
@@ -115,7 +124,7 @@ static const RcmServer_FxnDescAry RPCServer_fxnTab = {
 };
 #endif
 
-#define RPC_SVR_NUM_FXNS 2
+#define RPC_SVR_NUM_FXNS 3
 OmapRpc_FuncDeclaration RPCServerFxns[RPC_SVR_NUM_FXNS] =
 {
     { RPC_SKEL_Init2,
@@ -123,18 +132,27 @@ OmapRpc_FuncDeclaration RPCServerFxns[RPC_SVR_NUM_FXNS] =
             {
                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
                 {OmapRpc_Direction_In, OmapRpc_Param_U32, 1},
-                {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_U32), 1},
-            },
-        },
+                {OmapRpc_Direction_In, OmapRpc_PtrType(OmapRpc_Param_U32), 1}
+            }
+        }
     },
     { fxnTriple,
         { "fxnTriple", 2,
             {
                 {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
-                {OmapRpc_Direction_In, OmapRpc_Param_U32, 1}, // return
+                {OmapRpc_Direction_In, OmapRpc_Param_U32, 1}
             },
         },
     },
+    { fxnAdd,
+        { "fxnAdd", 3,
+            {
+                {OmapRpc_Direction_Out, OmapRpc_Param_S32, 1}, // return
+                {OmapRpc_Direction_In, OmapRpc_Param_S32, 1},
+                {OmapRpc_Direction_In, OmapRpc_Param_S32, 1}
+            }
+        }
+    }
 };
 
 static Int32 RPC_SKEL_SetParameter(UInt32 size, UInt32 *data)
@@ -220,6 +238,7 @@ static Int32 RPC_SKEL_Init2(UInt32 size, UInt32 *data)
 {
     System_printf("RPC_SKEL_Init2: size = 0x%x data = 0x%x\n", size,
                                                             (UInt32)data);
+    return 0;
 }
 
 /*
@@ -230,14 +249,34 @@ Int32 fxnTriple(UInt32 size, UInt32 *data)
     FxnTripleArgs *args;
     Int a;
 
+//  args = (FxnTripleArgs *)((UInt32)data + sizeof(map_info_type));
+    args = (FxnTripleArgs *)data;
+    a = args->a;
+
 #if CHATTER
-    System_printf("fxnTriple: Executing fxnTriple \n");
+    System_printf("fxnTriple: a=%d\n", a);
 #endif
 
-    args = (FxnTripleArgs *)((UInt32)data + sizeof(map_info_type));
+    return(a * 3);
+}
+
+/*
+ *  ======== fxnAdd ========
+ */
+Int32 fxnAdd(UInt32 size, UInt32 *data)
+{
+    FxnAddArgs *args;
+    Int a, b;
+
+    args = (FxnAddArgs *)data;
     a = args->a;
+    b = args->b;
+
+#if CHATTER
+    System_printf("fxnAdd: a=%d, b=%d\n", a, b);
+#endif
 
-    return a * 3;
+    return(a + b);
 }
 
 Void start_rpc_task()
index 6338306d17d1a7b16d71138b2875039199db868d..5fc5a121ead4ea059c622b9d27822ed45087f829 100644 (file)
@@ -66,7 +66,6 @@
 extern void start_ping_tasks();
 extern void start_resmgr_task();
 extern void start_hwSpinlock_task();
-extern void start_rpc_task();
 
 /*
  * OMX packet expected to have its data payload start with a payload of
@@ -248,6 +247,7 @@ Int main(Int argc, char* argv[])
     OMXServer_fxnTab.elem[0].addr.createFxn = RPC_SKEL_GetHandle;
 
     rcmServerParams.priority    = Thread_Priority_ABOVE_NORMAL;
+    rcmServerParams.stackSize   = 0x1000;
     rcmServerParams.fxns.length = OMXServer_fxnTab.length;
     rcmServerParams.fxns.elem   = OMXServer_fxnTab.elem;
 
@@ -270,10 +270,6 @@ Int main(Int argc, char* argv[])
     /* Start the ServiceMgr services */
     ServiceMgr_start(0);
 
-#if IPU
-    start_rpc_task();
-#endif
-
     BIOS_start();
 
     return (0);
index b7829aa73d0ffeeac591a470876aad753af83003..9352f3ca56fc43902cca9b798b7046ddb53c43f9 100644 (file)
 xdc.loadPackage('ti.ipc.ipcmgr');
 var BIOS        = xdc.useModule('ti.sysbios.BIOS');
 BIOS.addUserStartupFunction('&IpcMgr_rpmsgStartup');
+BIOS.addUserStartupFunction('&start_rpc_task');
+
+var Task = xdc.useModule('ti.sysbios.knl.Task');
+Task.defaultStackSize = 0x2000;
 
 xdc.loadPackage('ti.srvmgr');
 xdc.useModule('ti.srvmgr.omx.OmxSrvMgr');
index add304df1cf5c00b127b128669dabec017c4a10e..d07ff3705932f353178cc1e57a1bdf0db7c39ec9 100644 (file)
@@ -208,7 +208,6 @@ Void ServiceMgr_send(Service_Handle srvc, Ptr data, UInt16 len)
     /* Set special rpmsg_omx header so Linux side can strip it off: */
     hdr->type    = OMX_RAW_MSG;
     hdr->len     = len;
-    hdr->flags   = 0;
 
     /* Send it off (and no response expected): */
     MessageQCopy_send(dstProc, remote, local, data, HDRSIZE+len);
index 7035173d58454d7f09190e2a8b419dcd87ee268d..342c733e5d0c53af901cf6e9cb675f8949d9a968 100644 (file)
@@ -264,6 +264,7 @@ OmapRpc_Handle OmapRpc_createChannel(String channelName,
     obj->numFuncs = numFuncs+1;
     RcmServer_Params_init(&obj->rcmParams);
     obj->rcmParams.priority = Thread_Priority_ABOVE_NORMAL;
+    obj->rcmParams.stackSize = 0x1000;
     obj->rcmParams.fxns.length = obj->numFuncs;
     obj->rcmParams.fxns.elem = Memory_alloc(NULL, sizeof(RcmServer_FxnDesc)*obj->numFuncs, 0, NULL);
     if (obj->rcmParams.fxns.elem == NULL) {
index a89903281645b3bb5963d0224ad9ccfc7fac8658..415c2fd79cee3d79ab318cb0bc36d5018fa5129c 100644 (file)
@@ -116,17 +116,17 @@ typedef enum OmapRpc_MsgType {
     OmapRpc_MsgType_FUNCTION_INFO = 3,
     /** Ask the ServiceMgr to create a new instance of the service.
      * No secondary data is needed. */
-    OmapRpc_MsgType_CREATE_INSTANCE = 4,
+    OmapRpc_MsgType_CREATE_INSTANCE = 6,
     /** The return message from OMAPRPC_CREATE_INSTANCE,
      * contains the new endpoint address in the OmapRpc_InstanceHandle */
-    OmapRpc_MsgType_INSTANCE_CREATED = 5,
+    OmapRpc_MsgType_INSTANCE_CREATED = 8,
     /** Ask the Service Mgr to destroy an instance */
-    OmapRpc_MsgType_DESTROY_INSTANCE = 6,
+    OmapRpc_MsgType_DESTROY_INSTANCE = 4,
     /** The return message from OMAPRPC_DESTROY_INSTANCE.
      * contains the old endpoint address in the OmapRpc_InstanceHandle */
     OmapRpc_MsgType_INSTANCE_DESTROYED = 7,
     /** Ask the Service Instance to call a particular function */
-    OmapRpc_MsgType_CALL_FUNCTION = 8,
+    OmapRpc_MsgType_CALL_FUNCTION = 5,
     /** The return values from a function call */
     OmapRpc_MsgType_FUNCTION_RETURN = 9,
     /** Returned from either the ServiceMgr or Service Instance
index 6eb579a655dce6e47d5450338b9833f844f71131..8dad0094ae47d79c13ded4541a163625a3792d22 100644 (file)
@@ -38,7 +38,6 @@
 /* explicit references to global objects */
 var Build = xdc.useModule('xdc.bld.BuildEnvironment');
 var Pkg = xdc.useModule('xdc.bld.PackageContents');
-var smpBuild = java.lang.System.getenv("BUILD_SMP");
 
 /* clean lib folder */
 Pkg.generatedFiles.$add("lib/");
@@ -50,38 +49,30 @@ Pkg.attrs.exportCfg = true;
 
 /* list of libraries to build */
 var libArray = new Array();
-if (smpBuild == "1") {
-    /* omaprpc library for IPU SMP target */
-    libArray.push(
-        {
-            name: "ti.srvmgr.omaprpc_smp",
-            sources: [
-                "OmapRpc",
-            ],
-            libAttrs: {
-                defs: " -DSMP"
-            },
-            isas: [ "v7M" ],
-        }
-    );
-}
-else {
-    /* omaprpc library for regular targets */
-    libArray.push(
-        {
-            name: "ti.srvmgr.omaprpc",
-            sources: [
-                "OmapRpc",
-            ],
-        }
-    );
-}
 
-/* generate the package libraries */
-/* check if profile specified in XDCARGS */
-/* XDCARGS="... profile=debug ..." */
-var cmdlProf = (" " + arguments.join(" ") + " ").match(/ profile=([^ ]+) /);
-cmdlProf = cmdlProf != null ? cmdlProf[1] : null;
+/* omaprpc library for IPU SMP target */
+libArray.push(
+    {
+        name: "ti.srvmgr.omaprpc_smp",
+        sources: [
+            "OmapRpc",
+        ],
+        libAttrs: {
+            defs: " -DSMP"
+        },
+        isas: [ "v7M" ],
+    }
+);
+
+/* omaprpc library for regular targets */
+libArray.push(
+    {
+        name: "ti.srvmgr.omaprpc",
+        sources: [
+            "OmapRpc",
+        ],
+    }
+);
 
 /* ==== loop over array of libraries ==== */
 for (var i = 0; i < libArray.length; i++) {
@@ -91,19 +82,6 @@ for (var i = 0; i < libArray.length; i++) {
     for (var j = 0; j < Build.targets.length; j++) {
         var targ = Build.targets[j];
 
-        /* skip target if not compatible with source code */
-        if ("icw" in lib) {
-            var skipTarget = true;
-            var targIsaChain = "/" + targ.getISAChain().join("/") + "/";
-            for (var k = 0; k < lib.icw.length; k++) {
-                if (targIsaChain.match("/" + lib.icw[k] + "/")) {
-                    skipTarget = false;
-                    break;
-                }
-            }
-            if (skipTarget) continue;
-        }
-
         /* skip target if it does not generate code for the given isa */
         if ("isas" in lib) {
             var skipTarget = true;
@@ -117,11 +95,6 @@ for (var i = 0; i < libArray.length; i++) {
         /* ==== loop over all profiles ==== */
         for (var profile in targ.profiles) {
 
-            /* skip profile if different than specified on command line */
-            if ((cmdlProf != null) && (profile != cmdlProf)) {
-                continue;
-            }
-
             /* name = lib/profile/name.a+suffix */
             var name = "lib/" + profile + "/" + lib.name;
 
index c27c51bdcf2471ae476825dde2ede60d36974f19..9c6b49e01e8a28587305172892e9d261234dfbd2 100644 (file)
@@ -98,7 +98,6 @@ enum omx_error_codes {
 /**
  * struct omx_msg_hdr - common header for all OMX messages
  * @type:type of message, see enum omx_msg_types
- * @flags:currently unused, should be zero
  * @len:length of msg payload (in bytes)
  * @data:the msg payload (depends on the message type)
  *
@@ -107,13 +106,12 @@ enum omx_error_codes {
  */
 struct omx_msg_hdr {
     UInt32 type;
-    UInt32 flags;
     UInt32 len;
     Char   data[1];
 };
 
 /* define this here because we cannot use data[0] in struct above */
-#define HDRSIZE (3 * sizeof(UInt))
+#define HDRSIZE (2 * sizeof(UInt))
 
 struct omx_connect_req {
     Char name[48];