1 files changed, 635 insertions, 0 deletions

diff --git a/drivers/video/tegra/host/dev.c b/drivers/video/tegra/host/dev.c
new file mode 100644
index 00000000000..8f0c0393401
--- /dev/null
+++ b/drivers/video/tegra/host/dev.c
@@ -0,0 +1,635 @@
+/*
+ * drivers/video/tegra/host/dev.c
+ *
+ * Tegra Graphics Host Driver Entrypoint
+ *
+ * Copyright (c) 2010-2012, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/spinlock.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/uaccess.h>
+#include <linux/file.h>
+#include <linux/clk.h>
+#include <linux/hrtimer.h>
+
+#include "dev.h"
+#define CREATE_TRACE_POINTS
+#include <trace/events/nvhost.h>
+
+#include <linux/io.h>
+
+#include <linux/nvhost.h>
+#include <linux/nvhost_ioctl.h>
+#include <mach/nvmap.h>
+#include <mach/gpufuse.h>
+#include <mach/hardware.h>
+#include <mach/iomap.h>
+
+#include "debug.h"
+#include "nvhost_job.h"
+#include "t20/t20.h"
+#include "t30/t30.h"
+#include "bus_client.h"
+
+#define DRIVER_NAME             "host1x"
+
+int nvhost_major;
+int nvhost_minor;
+
+static unsigned int register_sets;
+
+struct nvhost_ctrl_userctx {
+        struct nvhost_master *dev;
+        u32 *mod_locks;
+};
+
+static int nvhost_ctrlrelease(struct inode *inode, struct file *filp)
+{
+        struct nvhost_ctrl_userctx *priv = filp->private_data;
+        int i;
+
+        trace_nvhost_ctrlrelease(priv->dev->dev->name);
+
+        filp->private_data = NULL;
+        if (priv->mod_locks[0])
+                nvhost_module_idle(priv->dev->dev);
+        for (i = 1; i < priv->dev->syncpt.nb_mlocks; i++)
+                if (priv->mod_locks[i])
+                        nvhost_mutex_unlock(&priv->dev->syncpt, i);
+        kfree(priv->mod_locks);
+        kfree(priv);
+        return 0;
+}
+
+static int nvhost_ctrlopen(struct inode *inode, struct file *filp)
+{
+        struct nvhost_master *host = container_of(inode->i_cdev, struct nvhost_master, cdev);
+        struct nvhost_ctrl_userctx *priv;
+        u32 *mod_locks;
+
+        trace_nvhost_ctrlopen(host->dev->name);
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        mod_locks = kzalloc(sizeof(u32) * host->syncpt.nb_mlocks, GFP_KERNEL);
+
+        if (!(priv && mod_locks)) {
+                kfree(priv);
+                kfree(mod_locks);
+                return -ENOMEM;
+        }
+
+        priv->dev = host;
+        priv->mod_locks = mod_locks;
+        filp->private_data = priv;
+        return 0;
+}
+
+static int nvhost_ioctl_ctrl_syncpt_read(struct nvhost_ctrl_userctx *ctx,
+        struct nvhost_ctrl_syncpt_read_args *args)
+{
+        if (args->id >= ctx->dev->syncpt.nb_pts)
+                return -EINVAL;
+        args->value = nvhost_syncpt_read(&ctx->dev->syncpt, args->id);
+        trace_nvhost_ioctl_ctrl_syncpt_read(args->id, args->value);
+        return 0;
+}
+
+static int nvhost_ioctl_ctrl_syncpt_incr(struct nvhost_ctrl_userctx *ctx,
+        struct nvhost_ctrl_syncpt_incr_args *args)
+{
+        if (args->id >= ctx->dev->syncpt.nb_pts)
+                return -EINVAL;
+        trace_nvhost_ioctl_ctrl_syncpt_incr(args->id);
+        nvhost_syncpt_incr(&ctx->dev->syncpt, args->id);
+        return 0;
+}
+
+static int nvhost_ioctl_ctrl_syncpt_waitex(struct nvhost_ctrl_userctx *ctx,
+        struct nvhost_ctrl_syncpt_waitex_args *args)
+{
+        u32 timeout;
+        int err;
+        if (args->id >= ctx->dev->syncpt.nb_pts)
+                return -EINVAL;
+        if (args->timeout == NVHOST_NO_TIMEOUT)
+                timeout = MAX_SCHEDULE_TIMEOUT;
+        else
+                timeout = (u32)msecs_to_jiffies(args->timeout);
+
+        err = nvhost_syncpt_wait_timeout(&ctx->dev->syncpt, args->id,
+                                        args->thresh, timeout, &args->value);
+        trace_nvhost_ioctl_ctrl_syncpt_wait(args->id, args->thresh,
+          args->timeout, args->value, err);
+
+        return err;
+}
+
+static int nvhost_ioctl_ctrl_module_mutex(struct nvhost_ctrl_userctx *ctx,
+        struct nvhost_ctrl_module_mutex_args *args)
+{
+        int err = 0;
+        if (args->id >= ctx->dev->syncpt.nb_mlocks ||
+            args->lock > 1)
+                return -EINVAL;
+
+        trace_nvhost_ioctl_ctrl_module_mutex(args->lock, args->id);
+        if (args->lock && !ctx->mod_locks[args->id]) {
+                if (args->id == 0)
+                        nvhost_module_busy(ctx->dev->dev);
+                else
+                        err = nvhost_mutex_try_lock(&ctx->dev->syncpt,
+                                        args->id);
+                if (!err)
+                        ctx->mod_locks[args->id] = 1;
+        } else if (!args->lock && ctx->mod_locks[args->id]) {
+                if (args->id == 0)
+                        nvhost_module_idle(ctx->dev->dev);
+                else
+                        nvhost_mutex_unlock(&ctx->dev->syncpt, args->id);
+                ctx->mod_locks[args->id] = 0;
+        }
+        return err;
+}
+
+static struct nvhost_device *get_ndev_by_moduleid(struct nvhost_master *host,
+                u32 id)
+{
+        int i;
+
+        for (i = 0; i < host->nb_channels; i++) {
+                struct nvhost_device *ndev = host->channels[i].dev;
+
+                /* display and dsi do not use channel for register programming.
+                 * so their channels do not have device instance.
+                 * hence skip such channels from here. */
+                if (ndev == NULL)
+                        continue;
+
+                if (id == ndev->moduleid)
+                        return ndev;
+        }
+        return NULL;
+}
+
+static int nvhost_ioctl_ctrl_module_regrdwr(struct nvhost_ctrl_userctx *ctx,
+        struct nvhost_ctrl_module_regrdwr_args *args)
+{
+        u32 num_offsets = args->num_offsets;
+        u32 *offsets = args->offsets;
+        u32 *values = args->values;
+        u32 vals[64];
+        struct nvhost_device *ndev;
+
+        trace_nvhost_ioctl_ctrl_module_regrdwr(args->id,
+                        args->num_offsets, args->write);
+        /* Check that there is something to read and that block size is
+         * u32 aligned */
+        if (num_offsets == 0 || args->block_size & 3)
+                return -EINVAL;
+
+        ndev = get_ndev_by_moduleid(ctx->dev, args->id);
+        if (!ndev)
+                return -EINVAL;
+
+        while (num_offsets--) {
+                int remaining = args->block_size >> 2;
+                u32 offs;
+                if (get_user(offs, offsets))
+                        return -EFAULT;
+                offsets++;
+                while (remaining) {
+                        i