Apply k4412 kernel from HardKernel for ODROID-X.

1 files changed, 841 insertions, 0 deletions

diff --git a/drivers/media/video/videobuf2-ion.c b/drivers/media/video/videobuf2-ion.c
new file mode 100644
index 00000000000..75185e54cf6
--- /dev/null
+++ b/drivers/media/video/videobuf2-ion.c
@@ -0,0 +1,841 @@
+/* linux/drivers/media/video/videobuf2-ion.c
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
+ * Implementation of Android ION memory allocator for videobuf2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/file.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/scatterlist.h>
+#include <linux/dma-mapping.h>
+#include <linux/ion.h>
+#include <linux/syscalls.h>
+
+#include <asm/cacheflush.h>
+
+#include <media/videobuf2-ion.h>
+#include <plat/iovmm.h>
+#include <plat/cpu.h>
+
+static int vb2_ion_debug;
+module_param(vb2_ion_debug, int, 0644);
+#define dbg(level, fmt, arg...)                                         \
+        do {                                                            \
+                if (vb2_ion_debug >= level)                             \
+                        printk(KERN_DEBUG "vb2_ion: " fmt, ## arg);     \
+        } while (0)
+
+#define SIZE_THRESHOLD SZ_1M
+
+struct vb2_ion_conf {
+        struct device           *dev;
+        const char              *name;
+
+        struct ion_client       *client;
+
+        unsigned long           align;
+        bool                    contig;
+        bool                    sharable;
+        bool                    cacheable;
+        bool                    use_mmu;
+        atomic_t                mmu_enable;
+
+        spinlock_t              slock;
+};
+
+struct vb2_ion_buf {
+        struct vm_area_struct           **vma;
+        int                             vma_count;
+        struct vb2_ion_conf             *conf;
+        struct vb2_vmarea_handler       handler;
+
+        struct ion_handle               *handle;        /* Kernel space */
+
+        dma_addr_t                      kva;
+        dma_addr_t                      dva;
+        unsigned long                   size;
+
+        struct scatterlist              *sg;
+        int                             nents;
+
+        atomic_t                        ref;
+
+        bool                            cacheable;
+};
+
+static void vb2_ion_put(void *buf_priv);
+
+static struct ion_client *vb2_ion_init_ion(struct vb2_ion *ion,
+                                           struct vb2_drv *drv)
+{
+        struct ion_client *client;
+        int ret;
+        int mask = ION_HEAP_EXYNOS_MASK | ION_HEAP_EXYNOS_CONTIG_MASK |
+                                                ION_HEAP_EXYNOS_USER_MASK;
+
+        client = ion_client_create(ion_exynos, mask, ion->name);
+        if (IS_ERR(client)) {
+                pr_err("ion_client_create: ion_name(%s)\n", ion->name);
+                return ERR_PTR(-EINVAL);
+        }
+
+        if (!drv->use_mmu)
+                return client;
+
+        ret = iovmm_setup(ion->dev);
+        if (ret) {
+                pr_err("iovmm_setup: ion_name(%s)\n", ion->name);
+                ion_client_destroy(client);
+                return ERR_PTR(-EINVAL);
+        }
+
+        return client;
+}
+
+static void vb2_ion_init_conf(struct vb2_ion_conf *conf,
+                              struct ion_client *client,
+                              struct vb2_ion *ion,
+                              struct vb2_drv *drv)
+{
+        conf->dev               = ion->dev;
+        conf->name              = ion->name;
+        conf->client            = client;
+        conf->contig            = ion->contig;
+        conf->cacheable         = ion->cacheable;
+        conf->align             = ion->align;
+        conf->use_mmu           = drv->use_mmu;
+
+        spin_lock_init(&conf->slock);
+}
+
+void *vb2_ion_init(struct vb2_ion *ion,
+                   struct vb2_drv *drv)
+{
+        struct ion_client *client;
+        struct vb2_ion_conf *conf;
+
+        conf = kzalloc(sizeof *conf, GFP_KERNEL);
+        if (!conf)
+                return ERR_PTR(-ENOMEM);
+
+        client = vb2_ion_init_ion(ion, drv);
+        if (IS_ERR(client)) {
+                kfree(conf);
+                return ERR_PTR(-EINVAL);
+        }
+
+        vb2_ion_init_conf(conf, client, ion, drv);
+
+        return conf;
+}
+EXPORT_SYMBOL_GPL(vb2_ion_init);
+
+void vb2_ion_cleanup(void *alloc_ctx)
+{
+        struct vb2_ion_conf *conf = alloc_ctx;
+
+        BUG_ON(!conf);
+
+        if (conf->use_mmu) {
+                if (atomic_read(&conf->mmu_enable)) {
+                        pr_warning("mmu_enable(%d)\n", atomic_read(&conf->mmu_enable));
+                        iovmm_deactivate(conf->dev);
+                }
+
+                iovmm_cleanup(conf->dev);
+        }
+
+        ion_client_destroy(conf->client);
+
+        kfree(alloc_ctx);
+}
+EXPORT_SYMBOL_GPL(vb2_ion_cleanup);
+
+void **vb2_ion_init_multi(unsigned int num_planes,
+                          struct vb2_ion *ion,
+                          struct vb2_drv *drv)
+{
+        struct ion_client *client;
+        struct vb2_ion_conf *conf;
+        void **alloc_ctxes;
+        int i;
+
+        /* allocate structure of alloc_ctxes */
+        alloc_ctxes = kzalloc((sizeof *alloc_ctxes + sizeof *conf) * num_planes,
+                              GFP_KERNEL);
+
+        if (!alloc_ctxes)
+                return ERR_PTR(-ENOMEM);
+
+        client = vb2_ion_init_ion(ion, drv);
+        if (IS_ERR(client)) {
+                kfree(alloc_ctxes);
+                return ERR_PTR(-EINVAL);
+        }
+
+        conf = (void *)(alloc_ctxes + num_planes);
+        for (i = 0; i < num_planes; ++i, ++conf) {
+                alloc_ctxes[i] = conf;
+                vb2_ion_init_conf(conf, client, ion, drv);
+        }
+
+        return alloc_ctxes;
+}
+EXPORT_SYMBOL_GPL(vb2_ion_init_multi);
+
+void vb2_ion_cleanup_multi(void **alloc_ctxes)
+{
+        struct vb2_ion_conf *conf = alloc_ctxes[0];
+
+        BUG_ON(!conf);
+
+        if (conf->use_mmu) {
+                if (atomic_read(&conf->mmu_enable)) {
+                        pr_warning("mmu_enable(%d)\n", atomic_read(&conf->mmu_enable));
+                        iovmm_deactivate(conf->dev);
+                }
+
+                iovmm_cleanup(conf->dev);
+        }
+
+        ion_client_destroy(conf->client);
+
+        kfree(alloc_ctxes);
+}
+EXPORT_SYMBOL_GPL(vb2_ion_cleanup_multi);
+
+static void *vb2_ion_alloc(void *alloc_ctx, unsigned long size)
+{
+        struct vb2_ion_conf     *conf = alloc_ctx;
+        struct vb2_ion_buf      *buf;
+        struct scatterlist      *sg;
+        size_t  len;
+        u32 heap = 0;
+        int ret = 0;
+
+        buf = kzalloc(sizeof *buf, GFP_KERNEL);
+        if (!buf) {
+                pr_err("no memory for vb2_ion_conf\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        /* Set vb2_ion_buf */
+        buf->conf = conf;
+        buf->size = size;
+        buf->cacheable = conf->cacheable;
+
+        /* Allocate: physical memory */
+        if (conf->contig)
+                heap = ION_HEAP_EXYNOS_CONTIG_MASK;
+        else
+                heap = ION_HEAP_EXYNOS_MASK;
+
+        buf->handle = ion_alloc(conf->client, size, conf->align, heap);
+        if (IS_ERR(buf->handle)) {
+                pr_err("ion_alloc of size %ld\n", size);
+                ret = -ENOMEM;
+                goto err_alloc;
+        }
+
+        /* Getting scatterlist */
+        buf->sg = ion_map_dma(conf->client, buf->handle);
+        if (IS_ERR(buf->sg)) {
+                pr_err("ion_map_dma conf->name(%s)\n", conf->name);
+                ret = -ENOMEM;
+                goto err_map_dma;
+        }
+        dbg(6, "PA(0x%x), SIZE(%x)\n", buf->sg->dma_address, buf->sg->length);
+
+        sg = buf->sg;
+        do {
+                buf->nents++;
+        } while ((sg = sg_next(sg)));
+        dbg(6, "buf->nents(0x%x)\n", buf->nents);
+
+        /* Map DVA */
+        if (conf->use_mmu) {
+                buf->dva = iovmm_map(conf->dev, buf->sg, 0, size);
+                if (!buf->dva) {
+                        pr_err("iovmm_map: conf->name(%s)\n", conf->name);
+                        goto err_ion_map_dva;
+                }
+                dbg(6, "DVA(0x%x)\n", buf->dva);
+        } else {
+                ret = ion_phys(conf->client, buf->handle,
+                               (unsigned long *)&buf->dva, &len);
+                if (ret) {
+                        pr_err("ion_phys: conf->name(%s)\n", conf->name);
+                        goto err_ion_map_dva;
+                }
+        }
+
+        /* Set struct vb2_vmarea_handler */
+        buf->handler.refcount = &buf->ref;
+        buf->handler.put = vb2_ion_put;
+        buf->handler.arg = buf;
+
+        atomic_inc(&buf->ref);
+
+        return buf;
+
+err_ion_map_dva:
+        ion_unmap_dma(conf->client, buf->handle);
+
+err_map_dma:
+        ion_free(conf->client, buf->handle);
+
+err_alloc:
+        kfree(buf);
+
+        return ERR_PTR(ret);
+}
+
+static void vb2_ion_put(void *buf_priv)
+{
+        struct vb2_ion_buf *buf = buf_priv;
+        struct vb2_ion_conf *conf = buf->conf;
+
+        dbg(6, "released: buf_refcnt(%d)\n", atomic_read(&buf->ref) - 1);
+
+        if (atomic_dec_and_test(&buf->ref)) {
+                if (conf->use_mmu)
+                        iovmm_unmap(conf->dev, buf->dva);
+
+                ion_unmap_dma(conf->client, buf->handle);
+
+                if (buf->kva)
+                        ion_unmap_kernel(conf->client, buf->handle);
+
+                ion_free(conf->client, buf->handle);
+
+                kfree(buf);
+        }
+}
+
+/**
+ * _vb2_ion_get_vma() - lock userspace mapped memory
+ * @vaddr:      starting virtual address of the area to be verified
+ * @size:       size of the area
+ * @res_vma:    will return locked copy of struct vm_area for the given area
+ *
+ * This function will go through memory area of size @size mapped at @vaddr
+ * If they are contiguous the virtual memory area is locked and a @res_vma is
+ * filled with the copy and @res_pa set to the physical address of the buffer.
+ *
+ * Returns 0 on success.
+ */
+static struct vm_area_struct **_vb2_ion_get_vma(unsigned long vaddr,
+                                        unsigned long size, int *vma_num)
+{
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma, *vma0;
+        struct vm_area_struct **vmas;
+        unsigned long prev_end = 0;
+        unsigned long end;
+        int i;
+
+        end = vaddr + size;
+
+        down_read(&mm->mmap_sem);
+        vma0 = find_vma(mm, vaddr);
+        if (!vma0) {
+                vmas = ERR_PTR(-EINVAL);
+                goto done;
+        }
+
+        for (*vma_num = 1, vma = vma0->vm_next, prev_end = vma0->vm_end;
+                vma && (end > vma->vm_start) && (prev_end == vma->vm_start);
+                                prev_end = vma->vm_end, vma = vma->vm_next) {
+                *vma_num += 1;
+        }
+
+        if (prev_end < end) {
+                vmas = ERR_PTR(-EINVAL);
+                goto done;
+        }
+
+        vmas = kmalloc(sizeof(*vmas) * *vma_num, GFP_KERNEL);
+        if (!vmas) {
+                vmas = ERR_PTR(-ENOMEM);
+                goto done;
+        }
+
+        for (i = 0; i < *vma_num; i++, vma0 = vma0->vm_next) {
+                vmas[i] = vb2_get_vma(vma0);
+                if (!vmas[i])
+                        break;
+        }
+
+        if (i < *vma_num) {
+                while (i-- > 0)
+                        vb2_put_vma(vmas[i]);
+
+                kfree(vmas);
+                vmas = ERR_PTR(-ENOMEM);
+        }
+
+done:
+        up_read(&mm->mmap_sem);
+        return vmas;
+}
+
+static void *vb2_ion_get_userptr(void *alloc_ctx, unsigned long vaddr,
+                                 unsigned long size, int write)
+{
+        struct vb2_ion_conf *conf = alloc_ctx;
+        struct vb2_ion_buf *buf = NULL;
+        size_t len;
+        int ret = 0;
+        bool malloced = false;
+        struct scatterlist *sg;
+        off_t offset;
+
+        /* Create vb2_ion_buf */
+        buf = kzalloc(sizeof *buf, GFP_KERNEL);
+        if (!buf) {
+                pr_err("kzalloc failed\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        /* Getting handle, client from DVA */
+        buf->handle = ion_import_uva(conf->client, vaddr, &offset);
+        if (IS_ERR(buf->handle)) {
+                if ((PTR_ERR(buf->handle) == -ENXIO) && conf->use_mmu) {
+                        int flags = ION_HEAP_EXYNOS_USER_MASK;
+
+                        if (write)
+                                flags |= ION_EXYNOS_WRITE_MASK;
+
+                        buf->handle = ion_exynos_get_user_pages(conf->client,
+                                                        vaddr, size, flags);
+                        if (IS_ERR(buf->handle))
+                                ret = PTR_ERR(buf->handle);
+                } else {
+                        ret = -EINVAL;
+                }
+
+                if (ret) {
+                        pr_err("%s: Failed to retrieving non-ion user buffer @ "
+                                "0x%lx (size:0x%lx, dev:%s, errno %ld)\n",
+                                __func__, vaddr, size, dev_name(conf->dev),
+                                        PTR_ERR(buf->handle));
+                        goto err_import_uva;
+                }
+
+                malloced = true;
+                offset = 0;
+        }
+
+        /* TODO: Need to check whether already DVA is created or not */
+
+        buf->sg = ion_map_dma(conf->client, buf->handle);
+        if (IS_ERR(buf->sg)) {
+                ret = -ENOMEM;
+                goto err_map_dma;
+        }
+        dbg(6, "PA(0x%x) size(%x)\n", buf->sg->dma_address, buf->sg->length);
+
+        sg = buf->sg;
+        do {
+                buf->nents++;
+        } while ((sg = sg_next(sg)));
+
+        /* Map DVA */
+        if (conf->use_mmu) {
+                buf->dva = iovmm_map(conf->dev, buf->sg, offset, size);
+                if (!buf->dva) {
+                        pr_err("iovmm_map: conf->name(%s)\n", conf->name);
+                        goto err_ion_map_dva;
+                }
+                dbg(6, "DVA(0x%x)\n", buf->dva);
+        } else {
+                ret = ion_phys(conf->client, buf->handle,
+                               (unsigned long *)&buf->dva, &len);
+                if (ret) {
+                        pr_err("ion_phys: conf->name(%s)\n", conf->name);
+                        goto err_ion_map_dva;
+                }
+
+                buf->dva += offset;
+        }
+
+        /* Set vb2_ion_buf */
+        buf->vma = _vb2_ion_get_vma(vaddr, size, &buf->vma_count);
+        if (IS_ERR(buf->vma)) {
+                pr_err("Failed acquiring VMA 0x%08lx\n", vaddr);
+
+                if (conf->use_mmu)
+                        iovmm_unmap(conf->dev, buf->dva);
+
+                goto err_get_vma;
+        }
+
+        buf->conf = conf;
+        buf->size = size;
+        buf->cacheable = conf->cacheable;
+
+        return buf;
+
+err_get_vma:    /* fall through */
+err_ion_map_dva:
+        ion_unmap_dma(conf->client, buf->handle);
+
+err_map_dma:
+        ion_free(conf->client, buf->handle);
+
+err_import_uva:
+        kfree(buf);
+
+        return ERR_PTR(ret);
+}
+
+static void vb2_ion_put_userptr(void *mem_priv)
+{
+        struct vb2_ion_buf *buf = mem_priv;
+        struct vb2_ion_conf *conf = buf->conf;
+        int i;
+
+        if (!buf) {
+                pr_err("No buffer to put\n");
+                return;
+        }
+
+        /* Unmap DVA, KVA */
+        if (conf->use_mmu)
+                iovmm_unmap(conf->dev, buf->dva);
+
+        ion_unmap_dma(conf->client, buf->handle);
+        if (buf->kva)
+                ion_unmap_kernel(conf->client, buf->handle);
+
+        ion_free(conf->client, buf->handle);
+
+        for (i = 0; i < buf->vma_count; i++)
+                vb2_put_vma(buf->vma[i]);
+        kfree(buf->vma);
+
+        kfree(buf);
+}
+
+static void *vb2_ion_cookie(void *buf_priv)
+{
+        struct vb2_ion_buf *buf = buf_priv;
+
+        if (!buf) {
+                pr_err("failed to get buffer\n");
+                return NULL;
+        }
+
+        return (void *)buf->dva;
+}
+
+static void *vb2_ion_vaddr(void *buf_priv)
+{
+        struct vb2_ion_buf *buf = buf_priv;
+        struct vb2_ion_conf *conf = buf->conf;
+
+        if (!buf) {
+                pr_err("failed to get buffer\n");
+                return NULL;
+        }
+
+        if (!buf->kva) {
+                buf->kva = (dma_addr_t)ion_map_kernel(conf->client, buf->handle);
+                if (IS_ERR(ERR_PTR(buf->kva))) {
+                        pr_err("ion_map_kernel handle(%x)\n",
+                                (u32)buf->handle);
+                        return NULL;
+                }
+        }
+
+        return (void *)buf->kva;
+}
+
+static unsigned int vb2_ion_num_users(void *buf_priv)
+{
+        struct vb2_ion_buf *buf = buf_priv;
+
+        return atomic_read(&buf->ref);
+}
+
+/**
+ * _vb2_ion_mmap_pfn_range() - map physical pages(vcm) to userspace
+ * @vma:        virtual memory region for the mapping
+ * @sg:         scatterlist to be mapped
+ * @nents:      number of scatterlist to be mapped
+ * @size:       size of the memory to be mapped
+ * @vm_ops:     vm operations to be assigned to the created area
+ * @priv:       private data to be associated with the area
+ *
+ * Returns 0 on success.
+ */
+static int _vb2_ion_mmap_pfn_range(struct vm_area_struct *vma,
+                                   struct scatterlist *sg,
+                                   int nents,
+                                   unsigned long size,
+                                   const struct vm_operations_struct *vm_ops,
+                                   void *priv)
+{
+        struct scatterlist *s;
+        dma_addr_t addr;
+        size_t len;
+        unsigned long org_vm_start = vma->vm_start;
+        int vma_size = vma->vm_end - vma->vm_start;
+        resource_size_t remap_size;
+        int mapped_size = 0;
+        int remap_break = 0;
+        int ret, i = 0;
+
+        for_each_sg(sg, s, nents, i) {
+                addr = sg_phys(s);
+                len = sg_dma_len(s);
+                if ((mapped_size + len) > vma_size) {
+                        remap_size = vma_size - mapped_size;
+                        remap_break = 1;
+                } else {
+                        remap_size = len;
+                }
+
+                ret = remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
+                                      remap_size, vma->vm_page_prot);
+                if (ret) {
+                        pr_err("Remapping failed, error: %d\n", ret);
+                        return ret;
+                }
+
+                dbg(6, "%dth page vaddr(0x%08x), paddr(0x%08x), size(0x%08x)\n",
+                        i++, (u32)vma->vm_start, addr, len);
+
+                mapped_size += remap_size;
+                vma->vm_start += len;
+
+                if (remap_break)
+                        break;
+        }
+
+        WARN_ON(size > mapped_size);
+
+        /* re-assign initial start address */
+        vma->vm_start           = org_vm_start;
+        vma->vm_flags           |= VM_DONTEXPAND | VM_RESERVED;
+        vma->vm_private_data    = priv;
+        vma->vm_ops             = vm_ops;
+
+        vma->vm_ops->open(vma);
+
+        return 0;
+}
+
+static int vb2_ion_mmap(void *buf_priv, struct vm_area_struct *vma)
+{
+        struct vb2_ion_buf *buf = buf_priv;
+
+        if (!buf) {
+                pr_err("No buffer to map\n");
+                return -EINVAL;
+        }
+
+        if (!buf->cacheable)
+                vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
+
+        return _vb2_ion_mmap_pfn_range(vma, buf->sg, buf->nents, buf->size,
+                                &vb2_common_vm_ops, &buf->handler);
+}
+
+const struct vb2_mem_ops vb2_ion_memops = {
+        .alloc          = vb2_ion_alloc,
+        .put            = vb2_ion_put,
+        .cookie         = vb2_ion_cookie,
+        .vaddr          = vb2_ion_vaddr,
+        .mmap           = vb2_ion_mmap,
+        .get_userptr    = vb2_ion_get_userptr,
+        .put_userptr    = vb2_ion_put_userptr,
+        .num_users      = vb2_ion_num_users,
+};
+EXPORT_SYMBOL_GPL(vb2_ion_memops);
+
+
+void vb2_ion_set_sharable(void *alloc_ctx, bool sharable)
+{
+        ((struct vb2_ion_conf *)alloc_ctx)->sharable = sharable;
+}
+
+void vb2_ion_set_cacheable(void *alloc_ctx, bool cacheable)
+{
+        ((struct vb2_ion_conf *)alloc_ctx)->cacheable = cacheable;
+}
+
+bool vb2_ion_get_cacheable(void *alloc_ctx)
+{
+        return ((struct vb2_ion_conf *)alloc_ctx)->cacheable;
+}
+
+#if 0
+int vb2_ion_cache_flush(struct vb2_buffer *vb, u32 num_planes)
+{
+        struct vb2_ion_conf *conf;
+        struct vb2_ion_buf *buf;
+        int i, ret;
+
+        for (i = 0; i < num_planes; i++) {
+                buf = vb->planes[i].mem_priv;
+                conf = buf->conf;
+
+                if (!buf->cacheable) {
+                        pr_warning("This is non-cacheable buffer allocator\n");
+                        return -EINVAL;
+                }
+
+                ret = dma_map_sg(conf->dev, buf->sg, buf->nents, DMA_TO_DEVICE);
+                if (ret) {
+                        pr_err("flush sg cnt(%d)\n", ret);
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+#else
+static void _vb2_ion_cache_flush_all(void)
+{
+        flush_cache_all();      /* L1 */
+        smp_call_function((void (*)(void *))__cpuc_flush_kern_all, NULL, 1);
+        outer_flush_all();      /* L2 */
+}
+
+static void _vb2_ion_cache_flush_range(struct vb2_ion_buf *buf,
+                                       unsigned long size)
+{
+        struct scatterlist *s;
+        phys_addr_t start, end;
+        int i;
+
+        /* sequentially traversal phys */
+        if (size > SZ_64K ) {
+                flush_cache_all();      /* L1 */
+                smp_call_function((void (*)(void *))__cpuc_flush_kern_all, NULL, 1);
+
+                for_each_sg(buf->sg, s, buf->nents, i) {
+                        start = sg_phys(s);
+                        end = start + sg_dma_len(s) - 1;
+
+                        outer_flush_range(start, end);  /* L2 */
+                }
+        } else {
+                dma_sync_sg_for_device(buf->conf->dev, buf->sg, buf->nents,
+                                                        DMA_BIDIRECTIONAL);
+                dma_sync_sg_for_cpu(buf->conf->dev, buf->sg, buf->nents,
+                                                        DMA_BIDIRECTIONAL);
+        }
+}
+
+
+int vb2_ion_cache_flush(struct vb2_buffer *vb, u32 num_planes)
+{
+        struct vb2_ion_conf *conf;
+        struct vb2_ion_buf *buf;
+        unsigned long size = 0;
+        int i;
+
+        for (i = 0; i < num_planes; i++) {
+                buf = vb->planes[i].mem_priv;
+                conf = buf->conf;
+
+                if (!buf->cacheable) {
+                        pr_warning("This is non-cacheable buffer allocator\n");
+                        return -EINVAL;
+                }
+
+                size += buf->size;
+        }
+
+        if (size > (unsigned long)SIZE_THRESHOLD) {
+                _vb2_ion_cache_flush_all();
+        } else {
+                for (i = 0; i < num_planes; i++) {
+                        buf = vb->planes[i].mem_priv;
+                        _vb2_ion_cache_flush_range(buf, size);
+                }
+        }
+
+        return 0;
+}
+#endif
+
+int vb2_ion_cache_inv(struct vb2_buffer *vb, u32 num_planes)
+{
+        struct vb2_ion_conf *conf;
+        struct vb2_ion_buf *buf;
+        int i;
+
+        for (i = 0; i < num_planes; i++) {
+                buf = vb->planes[i].mem_priv;
+                conf = buf->conf;
+                if (!buf->cacheable) {
+                        pr_warning("This is non-cacheable buffer allocator\n");
+                        return -EINVAL;
+                }
+
+                dma_unmap_sg(conf->dev, buf->sg, buf->nents, DMA_FROM_DEVICE);
+        }
+
+        return 0;
+}
+
+void vb2_ion_suspend(void *alloc_ctx)
+{
+        struct vb2_ion_conf *conf = alloc_ctx;
+        unsigned long flags;
+
+        if (!conf->use_mmu)
+                return;
+
+        spin_lock_irqsave(&conf->slock, flags);
+        if (!atomic_read(&conf->mmu_enable)) {
+                pr_warning("Already suspend: device(%x)\n", (u32)conf->dev);
+                return;
+        }
+
+        atomic_dec(&conf->mmu_enable);
+        iovmm_deactivate(conf->dev);
+        spin_unlock_irqrestore(&conf->slock, flags);
+
+}
+
+void vb2_ion_resume(void *alloc_ctx)
+{
+        struct vb2_ion_conf *conf = alloc_ctx;
+        int ret;
+        unsigned long flags;
+
+        if (!conf->use_mmu)
+                return;
+
+        spin_lock_irqsave(&conf->slock, flags);
+        if (atomic_read(&conf->mmu_enable)) {
+                pr_warning("Already resume: device(%x)\n", (u32)conf->dev);
+                return;
+        }
+
+        atomic_inc(&conf->mmu_enable);
+        ret = iovmm_activate(conf->dev);
+        if (ret) {
+                pr_err("iovmm_activate: dev(%x)\n", (u32)conf->dev);
+                atomic_dec(&conf->mmu_enable);
+        }
+        spin_unlock_irqrestore(&conf->slock, flags);
+}
+
+MODULE_AUTHOR("Jonghun, Han <jonghun.han@samsung.com>");
+MODULE_DESCRIPTION("Android ION allocator handling routines for videobuf2");
+MODULE_LICENSE("GPL");