Reduce external dependencies by pulling in MMRPC files

The ipcdev project is over 200k lines of code, of which we use only
about 600 lines. Pull the mmrpc project into this source base
to avoid this large external dependency. We do the same for the
kernel header that mmrpc needs. This will have to be kept up to date
with the current kernel version.

Signed-off-by: Andrew F. Davis <afd@ti.com>

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_ */