1 files changed, 419 insertions, 0 deletions

diff --git a/drivers/media/video/tegra/avp/trpc_local.c b/drivers/media/video/tegra/avp/trpc_local.c
new file mode 100644
index 00000000000..77692e09438
--- /dev/null
+++ b/drivers/media/video/tegra/avp/trpc_local.c
@@ -0,0 +1,419 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *   Dima Zavin <dima@android.com>
+ *
+ * Based on original NVRM code from NVIDIA, and a partial rewrite by
+ *   Gary King <gking@nvidia.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/err.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/miscdevice.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/tegra_rpc.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <linux/wait.h>
+
+#include "trpc.h"
+#include "trpc_sema.h"
+#include "nvavp.h"
+
+struct tegra_rpc_info {
+        struct trpc_endpoint    *rpc_ep;
+        struct tegra_sema_info  *sema;
+};
+
+/* ports names reserved for system functions, i.e. communicating with the
+ * AVP */
+static const char reserved_ports[][TEGRA_RPC_MAX_NAME_LEN] = {
+        "RPC_AVP_PORT",
+        "RPC_CPU_PORT",
+};
+static int num_reserved_ports = ARRAY_SIZE(reserved_ports);
+
+static void rpc_notify_recv(struct trpc_endpoint *ep);
+
+/* TODO: do we need to do anything when port is closed from the other side? */
+static struct trpc_ep_ops ep_ops = {
+        .notify_recv    = rpc_notify_recv,
+};
+
+static struct trpc_node rpc_node = {
+        .name   = "local",
+        .type   = TRPC_NODE_LOCAL,
+};
+
+static void rpc_notify_recv(struct trpc_endpoint *ep)
+{
+        struct tegra_rpc_info *info = trpc_priv(ep);
+
+        if (WARN_ON(!info))
+                return;
+        if (info->sema)
+                tegra_sema_signal(info->sema);
+}
+
+int tegra_rpc_open(struct tegra_rpc_info **info)
+{
+        struct tegra_rpc_info *new_info;
+
+        new_info = kzalloc(sizeof(struct tegra_rpc_info), GFP_KERNEL);
+        if (!new_info)
+                return -ENOMEM;
+
+        *info = new_info;
+        return 0;
+}
+
+static int local_rpc_open(struct inode *inode, struct file *file)
+{
+        struct tegra_rpc_info *info;
+        int ret = 0;
+
+        ret = tegra_rpc_open(&info);
+        if (ret < 0)
+                return -ENOMEM;
+
+        nonseekable_open(inode, file);
+        file->private_data = info;
+        return 0;
+}
+
+int tegra_rpc_release(struct tegra_rpc_info *info)
+{
+        if (info->rpc_ep)
+                trpc_close(info->rpc_ep);
+        if (info->sema)
+                trpc_sema_put(info->sema);
+        kfree(info);
+        return 0;
+}
+EXPORT_SYMBOL(tegra_rpc_release);
+
+static int local_rpc_release(struct inode *inode, struct file *file)
+{
+        struct tegra_rpc_info *info = file->private_data;
+
+        tegra_rpc_release(info);
+        file->private_data = NULL;
+        return 0;
+}
+
+static char uniq_name[] = "aaaaaaaa+";
+static const int uniq_len = sizeof(uniq_name) - 1;
+static DEFINE_MUTEX(uniq_lock);
+
+static void _gen_port_name(char *new_name)
+{
+        int i;
+
+        mutex_lock(&uniq_lock);
+        for (i = 0; i < uniq_len - 1; i++) {
+                ++uniq_name[i];
+                if (uniq_name[i] != 'z')
+                        break;
+                uniq_name[i] = 'a';
+        }
+        strlcpy(new_name, uniq_name, TEGRA_RPC_MAX_NAME_LEN);
+        mutex_unlock(&uniq_lock);
+}
+
+static int _validate_port_name(const char *name)
+{
+        int i;
+
+        for (i = 0; i < num_reserved_ports; i++)
+                if (!strncmp(name, reserved_ports[i], TEGRA_RPC_MAX_NAME_LEN))
+                        return -EINVAL;
+        return 0;
+}
+
+int tegra_rpc_port_create(struct tegra_rpc_info *info, char *name,
+                          struct tegra_sema_info *sema)
+{
+        struct trpc_endpoint *ep;
+        int ret = 0;
+
+        if (info->rpc_ep) {
+                ret = -EINVAL;
+                goto err;
+        }
+
+        name[TEGRA_RPC_MAX_NAME_LEN - 1] = '\0';
+        if (name[0]) {
+                ret = _validate_port_name(name);
+                if (ret)
+                        goto err;
+        } else {
+                _gen_port_name(name);
+        }
+        ep = trpc_create(&rpc_node, name, &ep_ops, info);
+        if (IS_ERR(ep)) {
+                ret = PTR_ERR(ep);
+                goto err;
+        }
+        info->rpc_ep = ep;
+        info->sema = sema;
+        return 0;
+
+err:
+        return ret;
+}
+
+int tegra_rpc_get_name(struct tegra_rpc_info *info, char* name)
+{
+        if (!info->rpc_ep)
+                return -EINVAL;
+
+        strcpy(name, trpc_name(info->rpc_ep));
+        return 0;
+}
+
+int tegra_rpc_port_connect(struct tegra_rpc_info *info, long timeout)
+{
+        if (!info->rpc_ep)
+                return -EINVAL;
+
+        return trpc_connect(info->rpc_ep, timeout);
+
+}
+
+int tegra_rpc_port_listen(struct tegra_rpc_info *info, long timeout)
+{
+        if (!info->rpc_ep)
+                return -EINVAL;
+
+        return trpc_wait_peer(info->rpc_ep, timeout);
+}
+
+static long local_rpc_ioctl(struct file *file, unsigned int cmd,
+                                unsigned long arg)
+{
+        struct tegra_rpc_info *info = file->private_data;
+        struct tegra_rpc_port_desc desc;
+        struct tegra_sema_info *sema = NULL;
+        int ret = 0;
+
+        if (_IOC_TYPE(cmd) != TEGRA_RPC_IOCTL_MAGIC ||
+                _IOC_NR(cmd) < TEGRA_RPC_IOCTL_MIN_NR ||
+                _IOC_NR(cmd) > TEGRA_RPC_IOCTL_MAX_NR) {
+                ret = -ENOTTY;
+                goto err;
+        }
+
+        switch (cmd) {
+        case TEGRA_RPC_IOCTL_PORT_CREATE:
+
+                if (_IOC_SIZE(cmd) != sizeof(struct tegra_rpc_port_desc))
+                        return -EINVAL;
+                if (copy_from_user(&desc, (void __user *)arg, sizeof(desc)))
+                        return -EFAULT;
+                if (desc.notify_fd != -1) {
+                        sema = trpc_sema_get_from_fd(desc.notify_fd);
+                        if (IS_ERR(sema)) {
+                                ret = PTR_ERR(sema);
+                                goto err;
+                        }
+                }
+
+                ret = tegra_rpc_port_create(info, desc.name, sema);
+                if (ret < 0)
+                        goto err;
+
+                break;
+        case TEGRA_RPC_IOCTL_PORT_GET_NAME:
+                if (!info->rpc_ep) {
+                        ret = -EINVAL;
+                        goto err;
+                }
+                if (copy_to_user((void __user *)arg,
+                                 trpc_name(info->rpc_ep),
+                                 TEGRA_RPC_MAX_NAME_LEN)) {
+                        ret = -EFAULT;
+                        goto err;
+                }
+                break;
+        case TEGRA_RPC_IOCTL_PORT_CONNECT:
+                if (!info->rpc_ep) {
+                        ret = -EINVAL;
+                        goto err;
+                }
+                ret = trpc_connect(info->rpc_ep, (long)arg);
+                if (ret) {
+                        pr_err("%s: can't connect to '%s' (%d)\n", __func__,
+                                   trpc_name(info->rpc_ep), ret);
+                        goto err;
+                }
+                break;
+        case TEGRA_RPC_IOCTL_PORT_LISTEN:
+                if (!info->rpc_ep) {
+                        ret = -EINVAL;
+                        goto err;
+                }
+                ret = trpc_wait_peer(info->rpc_ep, (long)arg);
+                if (ret) {
+                        pr_err("%s: error waiting for peer for '%s' (%d)\n",
+                                   __func__, trpc_name(info->rpc_ep), ret);
+                        goto err;
+                }
+                break;
+        default:
+                pr_err("%s: unknown cmd %d\n", __func__, _IOC_NR(cmd));
+                ret = -EINVAL;
+                goto err;
+        }
+
+        return 0;
+
+err:
+        if (ret && ret != -ERESTARTSYS)
+                pr_err("tegra_rpc: pid=%d ioctl=%x/%lx (%x) ret=%d\n",
+                           current->pid, cmd, arg, _IOC_NR(cmd), ret);
+        return (long)ret;
+}
+
+int tegra_rpc_write(struct tegra_rpc_info *info, u8* buf, size_t size)
+{
+        int ret;
+
+        if (!info->rpc_ep)
+                return -EINVAL;
+
+        if (TEGRA_RPC_MAX_MSG_LEN < size)
+                return -EINVAL;
+
+        ret = trpc_send_msg(&rpc_node, info->rpc_ep, buf, size,
+                                                GFP_KERNEL);
+        if (ret)
+                return ret;
+        return size;
+}
+
+static ssize_t local_rpc_write(struct file *file, const char __user *buf,
+                                   size_t count, loff_t *ppos)
+{
+        struct tegra_rpc_info *info = file->private_data;
+        u8 data[TEGRA_RPC_MAX_MSG_LEN];
+        int ret;
+
+        if (!info)
+                return -EINVAL;
+        else if (count > TEGRA_RPC_MAX_MSG_LEN)
+                return -EINVAL;
+
+        if (copy_from_user(data, buf, count))
+                return -EFAULT;
+
+        ret = trpc_send_msg(&rpc_node, info->rpc_ep, data, count,
+                                GFP_KERNEL);
+        if (ret)
+                return ret;
+        return count;
+}
+
+int tegra_rpc_read(struct tegra_rpc_info *info, u8 *buf, size_t max)
+{
+        int ret;
+
+        if (max > TEGRA_RPC_MAX_MSG_LEN)
+                return -EINVAL;
+
+        ret = trpc_recv_msg(&rpc_node, info->rpc_ep, buf,
+                                TEGRA_RPC_MAX_MSG_LEN, 0);
+        if (ret == 0)
+                return 0;
+        else if (ret < 0)
+                return ret;
+        else if (ret > max)
+                return -ENOSPC;
+
+        return ret;
+}
+
+static ssize_t local_rpc_read(struct file *file, char __user *buf, size_t max,
+                                  loff_t *ppos)
+{
+        struct tegra_rpc_info *info = file->private_data;
+        int ret;
+        u8 data[TEGRA_RPC_MAX_MSG_LEN];
+
+        if (max > TEGRA_RPC_MAX_MSG_LEN)
+                return -EINVAL;
+
+        ret = trpc_recv_msg(&rpc_node, info->rpc_ep, data,
+                                TEGRA_RPC_MAX_MSG_LEN, 0);
+        if (ret == 0)
+                return 0;
+        else if (ret < 0)
+                return ret;
+        else if (ret > max)
+                return -ENOSPC;
+        else if (copy_to_user(buf, data, ret))
+                return -EFAULT;
+
+        return ret;
+}
+
+static const struct file_operations local_rpc_misc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = local_rpc_open,
+        .release        = local_rpc_release,
+        .unlocked_ioctl = local_rpc_ioctl,
+        .write          = local_rpc_write,
+        .read           = local_rpc_read,
+};
+
+static struct miscdevice local_rpc_misc_device = {
+        .minor  = MISC_DYNAMIC_MINOR,
+        .name   = "tegra_rpc",
+        .fops   = &local_rpc_misc_fops,
+};
+
+int __init rpc_local_init(void)
+{
+        int ret;
+
+        ret = trpc_sema_init();
+        if (ret) {
+                pr_err("%s: error in trpc_sema_init\n", __func__);
+                goto err_sema_init;
+        }
+
+        ret = misc_register(&local_rpc_misc_device);
+        if (ret) {
+                pr_err("%s: can't register misc device\n", __func__);
+                goto err_misc;
+        }
+
+        ret = trpc_node_register(&rpc_node);
+        if (ret) {
+                pr_err("%s: can't register rpc node\n", __func__);
+                goto err_node_reg;
+        }
+        return 0;
+
+err_node_reg:
+        misc_deregister(&local_rpc_misc_device);
+err_misc:
+err_sema_init:
+        return ret;
+}
+
+module_init(rpc_local_init);