3 files changed, 938 insertions, 0 deletions

diff --git a/packages/ipcdev/ti/ipc/mm/MmRpc.c b/packages/ipcdev/ti/ipc/mm/MmRpc.c
new file mode 100644
index 0000000..223262f
--- /dev/null
+++ b/packages/ipcdev/ti/ipc/mm/MmRpc.c
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2012-2015, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  ======== MmRpc.c ========
+ */
+
+#include <stdio.h>
+#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 */
+
+
+
+#if defined(KERNEL_INSTALL_DIR)
+
+#ifdef linux
+#define _linux_ linux
+#undef linux
+#endif
+
+#define linux_version_include(kd) <kd/include/generated/uapi/linux/version.h>
+#include linux_version_include(KERNEL_INSTALL_DIR)
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0)
+#define linux_include(kd,m) <kd/include/linux/m.h>
+#else
+#define linux_include(kd,m) <kd/include/uapi/linux/m.h>
+#endif
+
+#include linux_include(KERNEL_INSTALL_DIR,rpmsg_rpc)
+
+#ifdef _linux_
+#define linux _linux
+#undef _linux_
+#endif
+
+#elif defined(IPC_BUILDOS_QNX)
+
+#include <ti/ipc/rpmsg_rpc.h>
+
+#elif defined(BUILDOS_ANDROID)
+#include <uapi/linux/rpmsg_rpc.h>
+
+#else
+#error Unsupported Operating System
+#endif
+
+#include "MmRpc.h"
+
+#if defined(KERNEL_INSTALL_DIR) || defined(BUILDOS_ANDROID)
+static int MmRpc_bufHandle(MmRpc_Handle handle, int cmd, int num,
+        MmRpc_BufDesc *desc);
+#endif
+
+
+/*
+ *  ======== MmRpc_Object ========
+ */
+typedef struct {
+    int                         fd;         /* device file descriptor */
+    struct rppc_create_instance connect;    /* connection object */
+} MmRpc_Object;
+
+/*
+ *  ======== MmRpc_Params_init ========
+ */
+void MmRpc_Params_init(MmRpc_Params *params)
+{
+    params->reserved = 0;
+}
+
+/*
+ *  ======== MmRpc_create ========
+ */
+int MmRpc_create(const char *service, const MmRpc_Params *params,
+        MmRpc_Handle *handlePtr)
+{
+    int             status = MmRpc_S_SUCCESS;
+    MmRpc_Object *  obj = NULL;
+    char            cbuf[RPPC_MAX_INST_NAMELEN+16];
+    (void)params;
+
+    if (service == NULL || handlePtr == NULL) {
+        status = MmRpc_E_INVALIDPARAM;
+        goto leave;
+    }
+
+    /* allocate the instance object */
+    obj = (MmRpc_Object *)calloc(1, sizeof(MmRpc_Object));
+
+    if (obj == NULL) {
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+
+    /* open the driver */
+    sprintf(cbuf, "/dev/%s", service);
+    obj->fd = open(cbuf, O_RDWR);
+
+    if (obj->fd < 0) {
+        printf("MmRpc_create: Error: open failed, name=%s\n", cbuf);
+        status = MmRpc_E_FAIL;
+        goto leave;
+    }
+
+    strncpy(obj->connect.name, service, (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 */
+    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)) {
+            close(obj->fd);
+        }
+        if (obj != NULL) {
+            free(obj);
+        }
+        if (handlePtr) {
+            *handlePtr = NULL;
+        }
+    }
+    else {
+        *handlePtr = (MmRpc_Handle)obj;
+    }
+
+    return(status);
+}
+
+/*
+ *  ======== MmRpc_delete ========
+ */
+int MmRpc_delete(MmRpc_Handle *handlePtr)
+{
+    int status = MmRpc_S_SUCCESS;
+    MmRpc_Object *obj;
+
+    if (handlePtr == NULL) {
+        return MmRpc_E_INVALIDPARAM;
+    }
+
+    obj = (MmRpc_Object *)(*handlePtr);
+
+    /* close the device */
+    if ((obj != NULL) && (obj->fd >= 0)) {
+        close(obj->fd);
+    }
+
+    /* free the instance object */
+    free((void *)(*handlePtr));
+    *handlePtr = NULL;
+
+    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;
+    MmRpc_Param *param;
+    void *msg = NULL;
+    int len;
+    unsigned int i;
+
+    if (handle == NULL || ctx == NULL || ret == NULL) {
+        status = MmRpc_E_INVALIDPARAM;
+        goto leave;
+    }
+
+    /* combine params and translation array into one contiguous message */
+    len = sizeof(struct rppc_function) +
+                (ctx->num_xlts * 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 parameters 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++) {
+        param = &ctx->params[i];
+
+        switch (param->type) {
+            case MmRpc_ParamType_Scalar:
+                rpfxn->params[i].type = RPPC_PARAM_TYPE_ATOMIC;
+                rpfxn->params[i].size = param->param.scalar.size;
+                rpfxn->params[i].data = param->param.scalar.data;
+                rpfxn->params[i].base = 0;
+                rpfxn->params[i].fd = 0;
+                break;
+
+            case MmRpc_ParamType_Ptr:
+                rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
+                rpfxn->params[i].size = param->param.ptr.size;
+                rpfxn->params[i].data = param->param.ptr.addr;
+                rpfxn->params[i].base = param->param.ptr.addr;
+                rpfxn->params[i].fd = param->param.ptr.handle;
+                break;
+
+            case MmRpc_ParamType_OffPtr:
+                rpfxn->params[i].type = RPPC_PARAM_TYPE_PTR;
+                rpfxn->params[i].size = param->param.offPtr.size;
+                rpfxn->params[i].data = param->param.offPtr.base +
+                        param->param.offPtr.offset;
+                rpfxn->params[i].base = param->param.offPtr.base;
+                rpfxn->params[i].fd = param->param.offPtr.handle;
+                break;
+
+            default:
+                printf("MmRpc_call: Error: invalid parameter type\n");
+                status = MmRpc_E_INVALIDPARAM;
+                goto leave;
+                break;
+        }
+    }
+
+    /* copy offset array into message */
+    rpfxn->num_translations = ctx->num_xlts;
+
+    for (i = 0; i < ctx->num_xlts; i++) {
+        /* pack the pointer translation entry */
+        rpfxn->translations[i].index = ctx->xltAry[i].index;
+        rpfxn->translations[i].offset = ctx->xltAry[i].offset;
+        rpfxn->translations[i].base = ctx->xltAry[i].base;
+        rpfxn->translations[i].fd = (int32_t)ctx->xltAry[i].handle;
+    }
+
+    /* 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);
+    }
+
+    return(status);
+}
+
+/*
+ *  ======== MmRcp_release ========
+ */
+int MmRpc_release(MmRpc_Handle handle, MmRpc_BufType type, int num,
+        MmRpc_BufDesc *desc)
+{
+    int stat = MmRpc_S_SUCCESS;
+
+    switch (type) {
+
+#if defined(KERNEL_INSTALL_DIR) || defined(BUILDOS_ANDROID)
+        case MmRpc_BufType_Handle:
+            stat = MmRpc_bufHandle(handle, RPPC_IOC_BUFUNREGISTER, num, desc);
+            break;
+
+#elif defined(IPC_BUILDOS_QNX)
+        case MmRpc_BufType_Ptr:
+            break;
+#endif
+        default:
+            printf("MmRpc_release: Error: unsupported type value: %d\n", type);
+            stat = MmRpc_E_INVALIDPARAM;
+            break;
+    }
+
+    if (stat < 0) {
+        printf("MmRpc_release: Error: unable to release buffer\n");
+    }
+
+    return(stat);
+}
+
+/*
+ *  ======== MmRcp_use ========
+ */
+int MmRpc_use(MmRpc_Handle handle, MmRpc_BufType type, int num,
+        MmRpc_BufDesc *desc)
+{
+    int stat = MmRpc_S_SUCCESS;
+
+    switch (type) {
+
+#if defined(KERNEL_INSTALL_DIR) || defined(BUILDOS_ANDROID)
+        case MmRpc_BufType_Handle:
+            stat = MmRpc_bufHandle(handle, RPPC_IOC_BUFREGISTER, num, desc);
+            break;
+
+#elif defined(IPC_BUILDOS_QNX)
+        case MmRpc_BufType_Ptr:
+            break;
+#endif
+        default:
+            printf("MmRpc_use: Error: unsupported type value: %d\n", type);
+            stat = MmRpc_E_INVALIDPARAM;
+            break;
+    }
+
+    if (stat < 0) {
+        printf("MmRpc_use: Error: unable to declare buffer use\n");
+    }
+
+    return(stat);
+}
+
+#if defined(KERNEL_INSTALL_DIR) || defined(BUILDOS_ANDROID)
+/*
+ *  ======== MmRpc_bufHandle ========
+ */
+int MmRpc_bufHandle(MmRpc_Handle handle, int cmd, int num, MmRpc_BufDesc *desc)
+{
+    int stat = MmRpc_S_SUCCESS;
+    MmRpc_Object *obj = (MmRpc_Object *)handle;
+    int i;
+    struct rppc_buf_fds reg = { num, NULL };
+
+    if (handle == NULL || desc == NULL) {
+        stat = MmRpc_E_INVALIDPARAM;
+        goto leave;
+    }
+
+    reg.fds = (int32_t *)malloc(num * sizeof(int32_t));
+
+    if (reg.fds == NULL) {
+        stat = MmRpc_E_NOMEM;
+        goto leave;
+    }
+
+    for (i = 0; i < num; i++) {
+        reg.fds[i] = desc[i].handle;
+    }
+
+    stat = ioctl(obj->fd, cmd, &reg);
+
+    if (stat < 0) {
+        stat = MmRpc_E_SYS;
+    }
+
+leave:
+    if (reg.fds != NULL) {
+        free(reg.fds);
+    }
+
+    return(stat);
+}
+#endif
diff --git a/packages/ipcdev/ti/ipc/mm/MmRpc.h b/packages/ipcdev/ti/ipc/mm/MmRpc.h
new file mode 100644
index 0000000..feee339
--- /dev/null
+++ b/packages/ipcdev/ti/ipc/mm/MmRpc.h
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2012-2014, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file       ti/ipc/mm/MmRpc.h
+ *
+ *  @brief      Multi-Media derived Remote Procedure Call
+ *
+ *  @note       MmRpc is currently only available for HLOS (Linux, QNX, Android).
+ */
+
+#ifndef ti_ipc_mm_MmRpc__include
+#define ti_ipc_mm_MmRpc__include
+
+/* add includes here */
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/*!
+ *  @brief  Operation is successful
+ */
+#define MmRpc_S_SUCCESS (0)
+
+/*!
+ *  @brief  Operation failed
+ */
+#define MmRpc_E_FAIL (-1)
+
+/*!
+ *  @brief  Invalid parameter type
+ */
+#define MmRpc_E_INVALIDPARAM (-2)
+
+/*!
+ *  @brief  Memory allocation failed
+ */
+#define MmRpc_E_NOMEM (-3)
+
+/*!
+ *  @brief  A system call failed
+ */
+#define MmRpc_E_SYS (-4)
+
+/*!
+ *  @brief  Size of parameter array in function context structure
+ */
+#define MmRpc_MAX_PARAMS (10)
+
+/*!
+ *  @brief  Maximum size of translation array in function context structure
+ */
+#define MmRpc_MAX_TRANSLATIONS (1024)
+
+/*!
+ *  @brief  Macro for computing offset to a field of a structure.
+ *
+ *  @code
+ *  struct foobar {
+ *      int a;
+ *      int *p;
+ *  };
+ *
+ *  struct foobar *sp = ...;
+ *  offset = MmRpc_OFFSET(sp, &sp->p);
+ *  struct foobar st = ...;
+ *  offset = MmRpc_OFFSET(&st, &st.p);
+ *  @endcode
+ */
+#define MmRpc_OFFSET(base, field) ((unsigned int)(field)-(unsigned int)(base))
+
+/*!
+ *  @brief      MmRpc_Handle type
+ */
+typedef struct MmRpc_Object *MmRpc_Handle;
+
+/*!
+ *  @brief      MmRpc_ParamType enum
+ */
+typedef enum {
+    MmRpc_ParamType_Scalar = 1, /*!< pass by value */
+    MmRpc_ParamType_Ptr,        /*!< data pointer */
+    MmRpc_ParamType_OffPtr,     /*!< buffer at offset in memory block */
+    MmRpc_ParamType_Elem        /*!< array element */
+} MmRpc_ParamType;
+
+/*!
+ *  @brief      MmRpc_Param type
+ */
+typedef struct {
+    MmRpc_ParamType     type;   /*!< parameter type */
+
+    union {
+        struct {
+            size_t      size;   /*!< size of the data */
+            size_t      data;   /*!< data (pass by value)*/
+        } scalar;
+
+        struct {
+            size_t      size;   /*!< size of the data referenced */
+            size_t      addr;   /*!< pointer value */
+            size_t      handle; /*!< memory allocator handle */
+        } ptr;
+
+        struct {
+            size_t      size;   /*!< size (bytes) of param structure */
+            size_t      base;   /*!< param address */
+            size_t      offset; /*!< offset within param */
+            size_t      handle; /*!< memory allocator handle */
+        } offPtr;
+
+    } param;
+} MmRpc_Param;
+
+typedef struct {
+    uint32_t    index;  /*!< parameter index to base pointer */
+    ptrdiff_t   offset; /*!< offset to embedded pointer
+                         *
+                         *   If param type is MmRpc_ParamType_Ptr, offset
+                         *   to embedded pointer from addr. If param type
+                         *   is MmRpc_ParamType_OffPtr, offset to embedded
+                         *   pointer from base+offset.
+                         */
+    size_t      base;   /*!< addr or file descriptor [+ data offset]
+                         *
+                         *   If param type is MmRpc_ParamType_Ptr, the
+                         *   value of the embedded pointer. If param type
+                         *   is MmRpc_ParamType_OffPtr, the file descriptor
+                         *   of the block referenced by the embedded pointer
+                         *   plus an optional data offset.
+                         */
+    size_t      handle; /*!< memory allocator handle */
+} MmRpc_Xlt;
+
+/*!
+ *  @brief      Function call context structure
+ */
+typedef struct {
+    uint32_t    fxn_id;         /*!< function id to call */
+    uint32_t    num_params;     /*!< number of parameters in params array */
+    MmRpc_Param params[MmRpc_MAX_PARAMS];
+                                /*!< the array of parameters */
+    uint32_t    num_xlts;       /*!< number of translations in xltAry */
+    MmRpc_Xlt * xltAry;         /*!< array of translations */
+} MmRpc_FxnCtx;
+
+/*!
+ *  @brief      Memory buffer types
+ *
+ *  @remark     Not all operating systems support all buffer types.
+ */
+typedef enum {
+    MmRpc_BufType_Handle,       /*!< memory allocator handle */
+    MmRpc_BufType_Ptr           /*!< buffer address */
+} MmRpc_BufType;
+
+/*!
+ *  @brief      Memory buffer descriptor
+ */
+typedef union {
+    size_t      handle;         /*!< file descriptor or handle */
+
+    struct {
+        size_t  addr;           /*!< address of memory buffer */
+        size_t  size;           /*!< size (bytes) of memory buffer */
+    } ptr;
+
+} MmRpc_BufDesc;
+
+/*!
+ *  @brief      Instance create parameters
+ */
+typedef struct {
+    int reserved;
+} MmRpc_Params;
+
+/*!
+ *  @brief      Invoke a remote procedure call
+ *
+ *  @param[in]      handle  MmRpc handle, obtained from MmRpc_create()
+ *  @param[in]      ctx     Context with which to invoke the remote service
+ *  @param[in, out] ret     Return value from the remotely invoked service
+ *
+ *  @pre        @c handle must be a valid handle for the service instance
+ *              returned by an earlier call to MmRpc_create().
+ *
+ *  @sa MmRpc_create()
+ *  @sa MmRpc_delete()
+ */
+int MmRpc_call(MmRpc_Handle handle, MmRpc_FxnCtx *ctx, int32_t *ret);
+
+/*!
+ *  @brief      Create an MmRpc instance
+ *
+ *  @param[in]      service     Name of the service to create
+ *  @param[in]      params      Initialized MmRpc parameters
+ *  @param[in,out]  handlePtr   Space to hold the MmRpc handle
+ *
+ *  @retval     MmRpc_S_SUCCESS @copydoc MmRpc_S_SUCCESS
+ *  @retval     MmRpc_E_FAIL    @copydoc MmRpc_E_FAIL
+ *
+ *  @remark     This instantiates an instance of the service on a remote
+ *              core.  Each remote instance consists of a unique thread
+ *              listening for requests made via a call to MmRpc_call().
+ */
+int MmRpc_create(const char *service, const MmRpc_Params *params,
+        MmRpc_Handle *handlePtr);
+
+/*!
+ *  @brief      Delete an MmRpc instance
+ *
+ *  @param[in]  handlePtr  MmRpc handle, obtained from MmRpc_create()
+ *
+ *  @pre        @c handlePtr must be a valid handle for the service instance
+ *              returned by an earlier call to MmRpc_create()
+ *
+ *  @sa MmRpc_create()
+ */
+int MmRpc_delete(MmRpc_Handle *handlePtr);
+
+/*!
+ *  @brief      Release buffers which were declared in use
+ *
+ *  @param[in]  handle  Service handle returned by MmRpc_create()
+ *  @param[in]  type    Buffer descriptor type
+ *  @param[in]  num     Number of elements in @c desc array
+ *  @param[in]  desc    Pointer to array of buffer descriptors
+ *
+ *  @pre        @c handle must be a valid handle for the service instance
+ *              returned by an earlier call to MmRpc_create().
+ *
+ *  @remark     When the remote processor no longer needs a reference
+ *              to a buffer, calling MmRpc_release() will release the
+ *              buffer and any associated resources.
+ *
+ *  @retval     MmRpc_S_SUCCESS         @copydoc MmRpc_S_SUCCESS
+ *  @retval     MmRpc_E_INVALIDPARAM    @copydoc MmRpc_E_INVALIDPARAM
+ *  @retval     MmRpc_E_NOMEM           @copydoc MmRpc_E_NOMEM
+ *  @retval     MmRpc_E_SYS             @copydoc MmRpc_E_SYS
+ *
+ *  @sa         MmRpc_use()
+ */
+int MmRpc_release(MmRpc_Handle handle, MmRpc_BufType type, int num,
+        MmRpc_BufDesc *desc);
+
+/*!
+ *  @brief      Declare the use of the given buffers
+ *
+ *  @param[in]  handle  Service handle returned by MmRpc_create()
+ *  @param[in]  type    Buffer descriptor type
+ *  @param[in]  num     Number of elements in @c desc array
+ *  @param[in]  desc    Pointer to array of buffer descriptors
+ *
+ *  @pre        @c handle must be a valid handle for the service instance
+ *              returned by an earlier call to MmRpc_create().
+ *
+ *  @remark     When using MmRpc_call() to invoke remote function calls,
+ *              any referenced buffers will be made available to the
+ *              remote processor only for the duration of the remote
+ *              function call. If the remote processor maintains a
+ *              reference to the buffer across multiple invocations of
+ *              MmRpc_call(), then the application must declare the buffer
+ *              "in use". This will make the buffer persistent.
+ *
+ *  @remark     The application must release the buffer when it is no
+ *              longer needed.
+ *
+ *  @code
+ *      #include <ti/ipc/mm/MmRpc.h>
+ *
+ *      MmRpc_BufDesc desc[2];
+ *
+ *      desc[0].handle = fd1;
+ *      desc[1].handle = fd2;
+ *
+ *      MmRpc_use(h, MmRpc_BufType_Handle, 2, desc);
+ *  @endcode
+ *
+ *  @retval     MmRpc_S_SUCCESS         @copydoc MmRpc_S_SUCCESS
+ *  @retval     MmRpc_E_INVALIDPARAM    @copydoc MmRpc_E_INVALIDPARAM
+ *  @retval     MmRpc_E_NOMEM           @copydoc MmRpc_E_NOMEM
+ *  @retval     MmRpc_E_SYS             @copydoc MmRpc_E_SYS
+ *
+ *  @sa         MmRpc_release()
+ */
+int MmRpc_use(MmRpc_Handle handle, MmRpc_BufType type, int num,
+        MmRpc_BufDesc *desc);
+
+/*!
+ *  @brief      Initialize the instance create parameter structure
+ *
+ */
+void MmRpc_Params_init(MmRpc_Params *params);
+
+
+#if defined(__cplusplus)
+}
+#endif
+#endif /* ti_ipc_mm_MmRpc__include */
diff --git a/packages/kernel-headers/uapi/linux/rpmsg_rpc.h b/packages/kernel-headers/uapi/linux/rpmsg_rpc.h
new file mode 100644
index 0000000..88b7126
--- /dev/null
+++ b/packages/kernel-headers/uapi/linux/rpmsg_rpc.h
@@ -0,0 +1,183 @@
+/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
+/*
+ * Remote Processor Procedure Call Driver
+ *
+ * Copyright (C) 2012-2019 Texas Instruments Incorporated - http://www.ti.com/
+ */
+
+#ifndef _UAPI_LINUX_RPMSG_RPC_H_
+#define _UAPI_LINUX_RPMSG_RPC_H_
+
+#include <linux/ioctl.h>
+
+/**
+ * struct rppc_buf_fds - rppc buffer registration/deregistration
+ * @num: number of file descriptors
+ * @fds: pointer to the array holding the file descriptors
+ */
+struct rppc_buf_fds {
+        uint32_t num;
+        int32_t *fds;
+};
+
+/*
+ * ioctl definitions
+ */
+#define RPPC_IOC_MAGIC          'r'
+#define RPPC_IOC_CREATE         _IOW(RPPC_IOC_MAGIC, 1, char *)
+#define RPPC_IOC_BUFREGISTER    _IOW(RPPC_IOC_MAGIC, 2, struct rppc_buf_fds)
+#define RPPC_IOC_BUFUNREGISTER  _IOW(RPPC_IOC_MAGIC, 3, struct rppc_buf_fds)
+#define RPPC_IOC_MAXNR          (4)
+
+#define RPPC_MAX_PARAMETERS     (10)
+#define RPPC_MAX_TRANSLATIONS   (1024)
+#define RPPC_MAX_INST_NAMELEN   (48)
+
+/**
+ * enum rppc_param_type - RPC function parameter type
+ * @RPPC_PARAM_TYPE_UNKNOWN: unrecognized parameter
+ * @RPPC_PARAM_TYPE_ATOMIC: an atomic data type, 1 byte to architecture limit
+ *                          sized bytes
+ * @RPPC_PARAM_TYPE_PTR: a pointer to shared memory. The fd field in the
+ *                       structures rppc_param and rppc_param_translation must
+ *                       contain the file descriptor of the associated dma_buf
+ * @RPPC_PARAM_TYPE_STRUCT: (unsupported) a structure type. Will be architecture
+ *                          width aligned in memory
+ *
+ * These enum values are used to identify the parameter type for every
+ * parameter argument of the remote function.
+ */
+enum rppc_param_type {
+        RPPC_PARAM_TYPE_UNKNOWN = 0,
+        RPPC_PARAM_TYPE_ATOMIC,
+        RPPC_PARAM_TYPE_PTR,
+        RPPC_PARAM_TYPE_STRUCT,
+};
+
+/**
+ * struct rppc_param_translation - pointer translation helper structure
+ * @index: index of the parameter where the translation needs to be done in.
+ *         used for computing the primary offset and mapping into kernel
+ *         the page from the buffer referred to in the corresponding parameter
+ * @offset: offset from the primary base pointer to the pointer to translate.
+ *          This is the secondary offset, and used either for mentioning the
+ *          offset from an structure array element base, or within a single
+ *          structure which itself is at an offset in an allocated buffer
+ * @base: the base user virtual address of the pointer to translate (used to
+ *        calculate translated pointer offset)
+ * @fd: dma_buf file descriptor of the allocated buffer pointer within which
+ *      the translated pointer is present
+ */
+struct rppc_param_translation {
+        uint32_t index;
+        ptrdiff_t offset;
+        size_t base;
+        int32_t fd;
+};
+
+/**
+ * struct rppc_param - descriptor structure for each parameter
+ * @type: type of the parameter, as dictated by enum rppc_param_type
+ * @size: size of the data (for atomic types) or size of the containing
+ *        structure in which translations are performed
+ * @data: either the parameter value itself (for atomic type) or
+ *        the actual user space pointer address to the data (for pointer type)
+ * @base: the base user space pointer address of the original allocated buffer,
+ *        providing a reference if data has the pointer that is at an offset
+ *        from the original pointer
+ * @fd: file descriptor of the exported allocation (will be used to
+ *      import the associated dma_buf within the driver).
+ */
+struct rppc_param {
+        uint32_t type;
+        size_t size;
+        size_t data;
+        size_t base;
+        int32_t fd;
+};
+
+/**
+ * struct rppc_function - descriptor structure for the remote function
+ * @fxn_id: index of the function to invoke on the opened rppc device
+ * @num_params: number of parameters filled in the params field
+ * @params: array of parameter descriptor structures
+ * @num_translations: number of in-place translations to be performed within
+ *                    the arguments.
+ * @translations: an open array of the translation descriptor structures, whose
+ *                length is given in @num_translations. Used for translating
+ *                the pointers within the function data.
+ *
+ * This is the primary descriptor structure passed down from the userspace,
+ * describing the function, its parameter arguments and the needed translations.
+ */
+struct rppc_function {
+        uint32_t fxn_id;
+        uint32_t num_params;
+        struct rppc_param params[RPPC_MAX_PARAMETERS];
+        uint32_t num_translations;
+        struct rppc_param_translation translations[0];
+};
+
+/**
+ * struct rppc_function_return - function return status descriptor structure
+ * @fxn_id: index of the function invoked on the opened rppc device
+ * @status: return value of the executed function
+ */
+struct rppc_function_return {
+        uint32_t fxn_id;
+        uint32_t status;
+};
+
+/**
+ * struct rppc_create_instance - rppc channel connector helper
+ * @name: Name of the rppc server device to establish a connection with
+ */
+struct rppc_create_instance {
+        char name[RPPC_MAX_INST_NAMELEN];
+};
+
+/*
+ * helper macros for manipulating the function index in the marshalled packet
+ */
+#define RPPC_DESC_EXEC_SYNC     (0x0100)
+#define RPPC_DESC_TYPE_MASK     (0x0F00)
+
+/*
+ * helper macros for manipulating the function index in the marshalled packet.
+ * The remote functions are offset by one relative to the client
+ * XXX: Remove the relative offset
+ */
+#define RPPC_SET_FXN_IDX(idx)   (((idx) + 1) | 0x80000000)
+#define RPPC_FXN_MASK(idx)      (((idx) - 1) & 0x7FFFFFFF)
+
+/**
+ * struct rppc_packet - the actual marshalled packet
+ * @desc: type of function execution, currently only synchronous function
+ *        invocations are supported
+ * @msg_id: an incremental message index identifier
+ * @flags: a combination of job id and pool id of the worker threads
+ *         of the server
+ * @fxn_id: id of the function to execute
+ * @result: result of the remotely executed function
+ * @data_size: size of the payload packet
+ * @data: variable payload, containing the marshalled function data.
+ *
+ * This is actually a condensed structure of the Remote Command Messaging
+ * (RCM) structure. The initial fields of the structure are used by the
+ * remote-side server to schedule the execution of the function. The actual
+ * variable payload data starts from the .data field. This marshalled packet
+ * is the payload for a rpmsg message.
+ *
+ * XXX: remove or mask unneeded fields, some fields can be stripped down
+ */
+struct rppc_packet {
+        uint16_t desc;
+        uint16_t msg_id;
+        uint32_t flags;
+        uint32_t fxn_id;
+        int32_t  result;
+        uint32_t data_size;
+        uint8_t  data[0];
+} __packed;
+
+#endif /* _UAPI_LINUX_RPMSG_RPC_H_ */