2 files changed, 600 insertions, 0 deletions

diff --git a/drivers/gpu/ion/tegra/Makefile b/drivers/gpu/ion/tegra/Makefile
new file mode 100644
index 00000000000..11cd003fb08
--- /dev/null
+++ b/drivers/gpu/ion/tegra/Makefile
@@ -0,0 +1 @@
+obj-y += tegra_ion.o
diff --git a/drivers/gpu/ion/tegra/tegra_ion.c b/drivers/gpu/ion/tegra/tegra_ion.c
new file mode 100644
index 00000000000..2252079279e
--- /dev/null
+++ b/drivers/gpu/ion/tegra/tegra_ion.c
@@ -0,0 +1,599 @@
+/*
+ * drivers/gpu/tegra/tegra_ion.c
+ *
+ * Copyright (C) 2011 Google, Inc.
+ * Copyright (C) 2011, NVIDIA Corporation.
+ *
+ * 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.
+ *
+ */
+
+#define pr_fmt(fmt)     "%s():%d: " fmt, __func__, __LINE__
+
+#include <linux/err.h>
+#include <linux/ion.h>
+#include <linux/tegra_ion.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/syscalls.h>
+#include <linux/io.h>
+#include "../ion_priv.h"
+
+#define CLIENT_HEAP_MASK 0xFFFFFFFF
+#define HEAP_FLAGS 0xFF
+
+#if !defined(CONFIG_TEGRA_NVMAP)
+#include "mach/nvmap.h"
+struct nvmap_device *nvmap_dev;
+#endif
+
+static struct ion_device *idev;
+static int num_heaps;
+static struct ion_heap **heaps;
+
+static int tegra_ion_pin(struct ion_client *client,
+                                unsigned int cmd,
+                                unsigned long arg)
+{
+        struct tegra_ion_pin_data data;
+        int ret;
+        struct ion_handle *on_stack[16];
+        struct ion_handle **refs = on_stack;
+        int i;
+        bool valid_handle;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
+                return -EFAULT;
+        if (data.count) {
+                size_t bytes = data.count * sizeof(struct ion_handle *);
+
+                if (data.count > ARRAY_SIZE(on_stack))
+                        refs = kmalloc(data.count * sizeof(*refs), GFP_KERNEL);
+                else
+                        refs = on_stack;
+                if (!refs)
+                        return -ENOMEM;
+                if (copy_from_user(refs, (void *)data.handles, bytes)) {
+                        ret = -EFAULT;
+                        goto err;
+                }
+        } else
+                return -EINVAL;
+
+        mutex_lock(&client->lock);
+        for (i = 0; i < data.count; i++) {
+                /* Ignore NULL pointers during unpin operation. */
+                if (!refs[i] && cmd == TEGRA_ION_UNPIN)
+                        continue;
+                valid_handle = ion_handle_validate(client, refs[i]);
+                if (!valid_handle) {
+                        WARN(1, "invalid handle passed h=0x%x", (u32)refs[i]);
+                        mutex_unlock(&client->lock);
+                        ret = -EINVAL;
+                        goto err;
+                }
+        }
+        mutex_unlock(&client->lock);
+
+        if (cmd == TEGRA_ION_PIN) {
+                ion_phys_addr_t addr;
+                size_t len;
+
+                for (i = 0; i < data.count; i++) {
+                        ret = ion_phys(client, refs[i], &addr, &len);
+                        if (ret)
+                                goto err;
+                        ion_handle_get(refs[i]);
+                        ret = put_user(addr, &data.addr[i]);
+                        if (ret)
+                                return ret;
+                }
+        } else if (cmd == TEGRA_ION_UNPIN) {
+                for (i = 0; i < data.count; i++) {
+                        if (refs[i])
+                                ion_handle_put(refs[i]);
+                }
+        }
+
+err:
+        if (ret) {
+                pr_err("error, ret=0x%x", ret);
+                /* FIXME: undo pinning. */
+        }
+        if (refs != on_stack)
+                kfree(refs);
+        return ret;
+}
+
+static int tegra_ion_alloc_from_id(struct ion_client *client,
+                                    unsigned int cmd,
+                                    unsigned long arg)
+{
+        struct tegra_ion_id_data data;
+        struct ion_buffer *buffer;
+        struct tegra_ion_id_data *user_data = (struct tegra_ion_id_data *)arg;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
+                return -EFAULT;
+        buffer = (struct ion_buffer *)data.id;
+        data.handle = ion_import(client, buffer);
+        data.size = buffer->size;
+        if (put_user(data.handle, &user_data->handle))
+                return -EFAULT;
+        if (put_user(data.size, &user_data->size))
+                return -EFAULT;
+        return 0;
+}
+
+static int tegra_ion_get_id(struct ion_client *client,
+                                            unsigned int cmd,
+                                            unsigned long arg)
+{
+        bool valid_handle;
+        struct tegra_ion_id_data data;
+        struct tegra_ion_id_data *user_data = (struct tegra_ion_id_data *)arg;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
+                return -EFAULT;
+
+        mutex_lock(&client->lock);
+        valid_handle = ion_handle_validate(client, data.handle);
+        mutex_unlock(&client->lock);
+
+        if (!valid_handle) {
+                WARN(1, "invalid handle passed\n");
+                return -EINVAL;
+        }
+
+        pr_debug("h=0x%x, b=0x%x, bref=%d",
+                (u32)data.handle, (u32)data.handle->buffer,
+                atomic_read(&data.handle->buffer->ref.refcount));
+        if (put_user((unsigned long)ion_handle_buffer(data.handle),
+                        &user_data->id))
+                return -EFAULT;
+        return 0;
+}
+
+static int tegra_ion_cache_maint(struct ion_client *client,
+                                 unsigned int cmd,
+                                 unsigned long arg)
+{
+        wmb();
+        return 0;
+}
+
+static int tegra_ion_rw(struct ion_client *client,
+                                unsigned int cmd,
+                                unsigned long arg)
+{
+        bool valid_handle;
+        struct tegra_ion_rw_data data;
+        char *kern_addr, *src;
+        int ret = 0;
+        size_t copied = 0;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
+                return -EFAULT;
+
+        if (!data.handle || !data.addr || !data.count || !data.elem_size)
+                return -EINVAL;
+
+        mutex_lock(&client->lock);
+        valid_handle = ion_handle_validate(client, data.handle);
+        mutex_unlock(&client->lock);
+
+        if (!valid_handle) {
+                WARN(1, "%s: invalid handle passed to get id.\n", __func__);
+                return -EINVAL;
+        }
+
+        if (data.elem_size == data.mem_stride &&
+            data.elem_size == data.user_stride) {
+                data.elem_size *= data.count;
+                data.mem_stride = data.elem_size;
+                data.user_stride = data.elem_size;
+                data.count = 1;
+        }
+
+        kern_addr = ion_map_kernel(client, data.handle);
+
+        while (data.count--) {
+                if (data.offset + data.elem_size > data.handle->buffer->size) {
+                        WARN(1, "read/write outside of handle\n");
+                        ret = -EFAULT;
+                        break;
+                }
+
+                src = kern_addr + data.offset;
+                if (cmd == TEGRA_ION_READ)
+                        ret = copy_to_user((void *)data.addr,
+                                            src, data.elem_size);
+                else
+                        ret = copy_from_user(src,
+                                            (void *)data.addr, data.elem_size);
+
+                if (ret)
+                        break;
+
+                copied += data.elem_size;
+                data.addr += data.user_stride;
+                data.offset += data.mem_stride;
+        }
+
+        ion_unmap_kernel(client, data.handle);
+        return ret;
+}
+
+static int tegra_ion_get_param(struct ion_client *client,
+                                        unsigned int cmd,
+                                        unsigned long arg)
+{
+        bool valid_handle;
+        struct tegra_ion_get_params_data data;
+        struct tegra_ion_get_params_data *user_data =
+                                (struct tegra_ion_get_params_data *)arg;
+        struct ion_buffer *buffer;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
+                return -EFAULT;
+
+        mutex_lock(&client->lock);
+        valid_handle = ion_handle_validate(client, data.handle);
+        mutex_unlock(&client->lock);
+
+        if (!valid_handle) {
+                WARN(1, "%s: invalid handle passed to get id.\n", __func__);
+                return -EINVAL;
+        }
+
+        buffer = ion_handle_buffer(data.handle);
+        data.align = 4096;
+        data.heap = 1;
+        ion_phys(client, data.handle, &data.addr, &data.size);
+
+        if (copy_to_user(user_data, &data, sizeof(data)))
+                return -EFAULT;
+
+        return 0;
+}
+
+static long tegra_ion_ioctl(struct ion_client *client,
+                                   unsigned int cmd,
+                                   unsigned long arg)
+{
+        int ret = -ENOTTY;
+
+        switch (cmd) {
+        case TEGRA_ION_ALLOC_FROM_ID:
+                ret = tegra_ion_alloc_from_id(client, cmd, arg);
+                break;
+        case TEGRA_ION_GET_ID:
+                ret = tegra_ion_get_id(client, cmd, arg);
+                break;
+        case TEGRA_ION_PIN:
+        case TEGRA_ION_UNPIN:
+                ret = tegra_ion_pin(client, cmd, arg);
+                break;
+        case TEGRA_ION_CACHE_MAINT:
+                ret = tegra_ion_cache_maint(client, cmd, arg);
+                break;
+        case TEGRA_ION_READ:
+        case TEGRA_ION_WRITE:
+                ret = tegra_ion_rw(client, cmd, arg);
+                break;
+        case TEGRA_ION_GET_PARAM:
+                ret = tegra_ion_get_param(client, cmd, arg);
+                break;
+        default:
+                WARN(1, "Unknown custom ioctl\n");
+                return -ENOTTY;
+        }
+        return ret;
+}
+
+int tegra_ion_probe(struct platform_device *pdev)
+{
+        struct ion_platform_data *pdata = pdev->dev.platform_data;
+        int i;
+
+        num_heaps = pdata->nr;
+
+        heaps = kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);
+
+        idev = ion_device_create(tegra_ion_ioctl);
+        if (IS_ERR_OR_NULL(idev)) {
+                kfree(heaps);
+                return PTR_ERR(idev);
+        }
+
+        /* create the heaps as specified in the board file */
+        for (i = 0; i < num_heaps; i++) {
+                struct ion_platform_heap *heap_data = &pdata->heaps[i];
+
+                heaps[i] = ion_heap_create(heap_data);
+                if (IS_ERR_OR_NULL(heaps[i])) {
+                        pr_warn("%s(type:%d id:%d) isn't supported\n",
+                                heap_data->name,
+                                heap_data->type, heap_data->id);
+                        continue;
+                }
+                ion_device_add_heap(idev, heaps[i]);
+        }
+        platform_set_drvdata(pdev, idev);
+#if !defined(CONFIG_TEGRA_NVMAP)
+        nvmap_dev = (struct nvmap_device *)idev;
+#endif
+        return 0;
+}
+
+int tegra_ion_remove(struct platform_device *pdev)
+{
+        struct ion_device *idev = platform_get_drvdata(pdev);
+        int i;
+
+        ion_device_destroy(idev);
+        for (i = 0; i < num_heaps; i++)
+                ion_heap_destroy(heaps[i]);
+        kfree(heaps);
+        return 0;
+}
+
+static struct platform_driver ion_driver = {
+        .probe = tegra_ion_probe,
+        .remove = tegra_ion_remove,
+        .driver = { .name = "ion-tegra" }
+};
+
+static int __init ion_init(void)
+{
+        return platform_driver_register(&ion_driver);
+}
+
+static void __exit ion_exit(void)
+{
+        platform_driver_unregister(&ion_driver);
+}
+
+fs_initcall(ion_init);
+module_exit(ion_exit);
+
+#if !defined(CONFIG_TEGRA_NVMAP)
+struct nvmap_client *nvmap_create_client(struct nvmap_device *dev,
+                                         const char *name)
+{
+        return ion_client_create(dev, CLIENT_HEAP_MASK, name);
+}
+
+struct nvmap_handle_ref *nvmap_alloc(struct nvmap_client *client, size_t size,
+                                     size_t align, unsigned int flags,
+                                     unsigned int heap_mask)
+{
+        return ion_alloc(client, size, align, HEAP_FLAGS);
+}
+
+void nvmap_free(struct nvmap_client *client, struct nvmap_handle_ref *r)
+{
+        ion_free(client, r);
+}
+
+void *nvmap_mmap(struct nvmap_handle_ref *r)
+{
+        return ion_map_kernel(r->client, r);
+}
+
+void nvmap_munmap(struct nvmap_handle_ref *r, void *addr)
+{
+        ion_unmap_kernel(r->client, r);
+}
+
+struct nvmap_client *nvmap_client_get_file(int fd)
+{
+        return ion_client_get_file(fd);
+}
+
+struct nvmap_client *nvmap_client_get(struct nvmap_client *client)
+{
+        ion_client_get(client);
+        return client;
+}
+
+void nvmap_client_put(struct nvmap_client *c)
+{
+        ion_client_put(c);
+}
+
+phys_addr_t nvmap_pin(struct nvmap_client *c, struct nvmap_handle_ref *r)
+{
+        ion_phys_addr_t addr;
+        size_t len;
+
+        ion_handle_get(r);
+        ion_phys(c, r, &addr, &len);
+        wmb();
+        return addr;
+}
+
+phys_addr_t nvmap_handle_address(struct nvmap_client *c, unsigned long id)
+{
+        struct ion_handle *handle;
+        ion_phys_addr_t addr;
+        size_t len;
+
+        handle = nvmap_convert_handle_u2k(id);
+        ion_phys(c, handle, &addr, &len);
+        return addr;
+}
+
+void nvmap_unpin(struct nvmap_client *client, struct nvmap_handle_ref *r)
+{
+        if (r)
+                ion_handle_put(r);
+}
+
+static int nvmap_reloc_pin_array(struct ion_client *client,
+                                 const struct nvmap_pinarray_elem *arr,
+                                 int nr, struct ion_handle *gather)
+{
+        struct ion_handle *last_patch = NULL;
+        void *patch_addr;
+        ion_phys_addr_t pin_addr;
+        size_t len;
+        int i;
+
+        for (i = 0; i < nr; i++) {
+                struct ion_handle *patch;
+                struct ion_handle *pin;
+                ion_phys_addr_t reloc_addr;
+
+                /* all of the handles are validated and get'ted prior to
+                 * calling this function, so casting is safe here */
+                pin = (struct ion_handle *)arr[i].pin_mem;
+
+                if (arr[i].patch_mem == (unsigned long)last_patch) {
+                        patch = last_patch;
+                } else if (arr[i].patch_mem == (unsigned long)gather) {
+                        patch = gather;
+                } else {
+                        if (last_patch)
+                                ion_handle_put(last_patch);
+
+                        ion_handle_get((struct ion_handle *)arr[i].patch_mem);
+                        patch = (struct ion_handle *)arr[i].patch_mem;
+                        if (!patch)
+                                return -EPERM;
+                        last_patch = patch;
+                }
+
+                patch_addr = ion_map_kernel(client, patch);
+                patch_addr = patch_addr + arr[i].patch_offset;
+
+                ion_phys(client, pin, &pin_addr, &len);
+                reloc_addr = pin_addr + arr[i].pin_offset;
+                __raw_writel(reloc_addr, patch_addr);
+                ion_unmap_kernel(client, patch);
+        }
+
+        if (last_patch)
+                ion_handle_put(last_patch);
+
+        wmb();
+        return 0;
+}
+
+int nvmap_pin_array(struct nvmap_client *client, struct nvmap_handle *gather,
+                    const struct nvmap_pinarray_elem *arr, int nr,
+                    struct nvmap_handle **unique)
+{
+        int i;
+        int count = 0;
+
+        /* FIXME: take care of duplicate ones & validation. */
+        for (i = 0; i < nr; i++) {
+                unique[i] = (struct nvmap_handle *)arr[i].pin_mem;
+                nvmap_pin(client, (struct nvmap_handle_ref *)unique[i]);
+                count++;
+        }
+        nvmap_reloc_pin_array((struct ion_client *)client,
+                arr, nr, (struct ion_handle *)gather);
+        return nr;
+}
+
+void nvmap_unpin_handles(struct nvmap_client *client,
+                         struct nvmap_handle **h, int nr)
+{
+        int i;
+
+        for (i = 0; i < nr; i++)
+                nvmap_unpin(client, h[i]);
+}
+
+int nvmap_patch_word(struct nvmap_client *client,
+                     struct nvmap_handle *patch,
+                     u32 patch_offset, u32 patch_value)
+{
+        void *vaddr;
+        u32 *patch_addr;
+
+        vaddr = ion_map_kernel(client, patch);
+        patch_addr = vaddr + patch_offset;
+        __raw_writel(patch_value, patch_addr);
+        wmb();
+        ion_unmap_kernel(client, patch);
+        return 0;
+}
+
+struct nvmap_handle *nvmap_handle_get(struct nvmap_handle *h);
+struct nvmap_handle *nvmap_get_handle_id(struct nvmap_client *client,
+                                         unsigned long id)
+{
+        struct ion_handle *handle;
+
+        handle = (struct ion_handle *)nvmap_convert_handle_u2k(id);
+        pr_debug("id=0x%x, h=0x%x,c=0x%x",
+                (u32)id, (u32)handle, (u32)client);
+        nvmap_handle_get(handle);
+        return handle;
+}
+
+struct nvmap_handle_ref *nvmap_duplicate_handle_id(struct nvmap_client *client,
+                                                   unsigned long id)
+{
+        struct ion_buffer *buffer;
+        struct ion_handle *handle;
+        struct ion_client *ion_client = client;
+
+        handle = (struct ion_handle *)nvmap_convert_handle_u2k(id);
+        pr_debug("id=0x%x, h=0x%x,c=0x%x",
+                (u32)id, (u32)handle, (u32)client);
+        buffer = handle->buffer;
+
+        handle = ion_handle_create(client, buffer);
+
+        mutex_lock(&ion_client->lock);
+        ion_handle_add(ion_client, handle);
+        mutex_unlock(&ion_client->lock);
+
+        pr_debug("dup id=0x%x, h=0x%x", (u32)id, (u32)handle);
+        return handle;
+}
+
+void _nvmap_handle_free(struct nvmap_handle *h)
+{
+        ion_handle_put(h);
+}
+
+struct nvmap_handle_ref *nvmap_alloc_iovm(struct nvmap_client *client,
+        size_t size, size_t align, unsigned int flags, unsigned int iova_start)
+{
+        struct ion_handle *h;
+
+        h = ion_alloc(client, size, align, 0xFF);
+        ion_remap_dma(client, h, iova_start);
+        return h;
+}
+
+void nvmap_free_iovm(struct nvmap_client *client, struct nvmap_handle_ref *r)
+{
+        ion_free(client, r);
+}
+
+struct nvmap_handle *nvmap_handle_get(struct nvmap_handle *h)
+{
+        ion_handle_get(h);
+        return h;
+}
+
+void nvmap_handle_put(struct nvmap_handle *h)
+{
+        ion_handle_put(h);
+}
+
+#endif