* core.c has implemented the platform dirver methods, file
operations and v4l2 registration.

 * helpers.c has implemented common helper functions for:
   - buffer management

   - vb2_ops and functions for format propagation,

   - functions for allocating and freeing buffers for
   internal usage. The buffer parameters describing internal
   buffers depends on current format, resolution and codec.

   - functions for calculation of current load of the
   hardware. Depending on the count of instances and
   resolutions it selects the best clock rate for the video
   core.

Signed-off-by: Stanimir Varbanov <stanimir.varba...@linaro.org>
---
 drivers/media/platform/qcom/venus/core.c    | 474 +++++++++++++++++++++
 drivers/media/platform/qcom/venus/core.h    | 296 +++++++++++++
 drivers/media/platform/qcom/venus/helpers.c | 621 ++++++++++++++++++++++++++++
 drivers/media/platform/qcom/venus/helpers.h |  41 ++
 4 files changed, 1432 insertions(+)
 create mode 100644 drivers/media/platform/qcom/venus/core.c
 create mode 100644 drivers/media/platform/qcom/venus/core.h
 create mode 100644 drivers/media/platform/qcom/venus/helpers.c
 create mode 100644 drivers/media/platform/qcom/venus/helpers.h

diff --git a/drivers/media/platform/qcom/venus/core.c 
b/drivers/media/platform/qcom/venus/core.c
new file mode 100644
index 000000000000..77fb77cadefe
--- /dev/null
+++ b/drivers/media/platform/qcom/venus/core.c
@@ -0,0 +1,474 @@
+/*
+ * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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/clk.h>
+#include <linux/init.h>
+#include <linux/ioctl.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/remoteproc.h>
+#include <linux/pm_runtime.h>
+#include <media/videobuf2-v4l2.h>
+#include <media/v4l2-mem2mem.h>
+#include <media/v4l2-ioctl.h>
+
+#include "core.h"
+#include "vdec.h"
+#include "venc.h"
+
+static void venus_sys_error_handler(struct work_struct *work)
+{
+       struct venus_core *core =
+                       container_of(work, struct venus_core, work.work);
+       int ret;
+
+       hfi_core_deinit(core);
+
+       mutex_lock(&core->lock);
+
+       rproc_report_crash(core->rproc, RPROC_FATAL_ERROR);
+       rproc_shutdown(core->rproc);
+
+       ret = rproc_boot(core->rproc);
+       if (ret)
+               goto exit;
+
+       enable_irq(core->irq);
+
+       core->state = CORE_INIT;
+
+exit:
+       mutex_unlock(&core->lock);
+}
+
+static void venus_event_notify(struct venus_core *core, u32 event)
+{
+       struct venus_inst *inst;
+
+       switch (event) {
+       case EVT_SYS_WATCHDOG_TIMEOUT:
+       case EVT_SYS_ERROR:
+               break;
+       default:
+               return;
+       }
+
+       mutex_lock(&core->lock);
+       core->sys_error = true;
+       list_for_each_entry(inst, &core->instances, list)
+               inst->ops->event_notify(inst, EVT_SESSION_ERROR, NULL);
+       mutex_unlock(&core->lock);
+
+       disable_irq_nosync(core->irq);
+
+       /*
+        * Sleep for 5 sec to ensure venus has completed any pending cache
+        * operations. Without this sleep, we see device reset when firmware is
+        * unloaded after a system error.
+        */
+       schedule_delayed_work(&core->work, msecs_to_jiffies(5000));
+}
+
+static const struct hfi_core_ops venus_core_ops = {
+       .event_notify = venus_event_notify,
+};
+
+static int venus_open(struct file *file)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct venus_core *core = video_drvdata(file);
+       struct venus_inst *inst;
+       int ret;
+
+       inst = kzalloc(sizeof(*inst), GFP_KERNEL);
+       if (!inst)
+               return -ENOMEM;
+
+       INIT_LIST_HEAD(&inst->registeredbufs);
+       INIT_LIST_HEAD(&inst->internalbufs);
+       INIT_LIST_HEAD(&inst->list);
+       mutex_init(&inst->lock);
+
+       inst->core = core;
+
+       if (vdev == core->vdev_dec) {
+               inst->session_type = VIDC_SESSION_TYPE_DEC;
+               ret = vdec_open(inst);
+               if (ret)
+                       goto err_free_inst;
+               v4l2_fh_init(&inst->fh, core->vdev_dec);
+       } else {
+               inst->session_type = VIDC_SESSION_TYPE_ENC;
+               ret = venc_open(inst);
+               if (ret)
+                       goto err_free_inst;
+               v4l2_fh_init(&inst->fh, core->vdev_enc);
+       }
+
+       inst->fh.ctrl_handler = &inst->ctrl_handler;
+       v4l2_fh_add(&inst->fh);
+       inst->fh.m2m_ctx = inst->m2m_ctx;
+       file->private_data = &inst->fh;
+
+       return 0;
+
+err_free_inst:
+       kfree(inst);
+       return ret;
+}
+
+static int venus_close(struct file *file)
+{
+       struct venus_inst *inst = to_inst(file);
+
+       if (inst->session_type == VIDC_SESSION_TYPE_DEC)
+               vdec_close(inst);
+       else
+               venc_close(inst);
+
+       mutex_destroy(&inst->lock);
+
+       v4l2_fh_del(&inst->fh);
+       v4l2_fh_exit(&inst->fh);
+
+       kfree(inst);
+       return 0;
+}
+
+static const struct v4l2_file_operations venus_fops = {
+       .owner = THIS_MODULE,
+       .open = venus_open,
+       .release = venus_close,
+       .unlocked_ioctl = video_ioctl2,
+       .poll = v4l2_m2m_fop_poll,
+       .mmap = v4l2_m2m_fop_mmap,
+#ifdef CONFIG_COMPAT
+       .compat_ioctl32 = v4l2_compat_ioctl32,
+#endif
+};
+
+static int venus_clks_get(struct venus_core *core)
+{
+       const struct venus_resources *res = core->res;
+       struct device *dev = core->dev;
+       unsigned int i;
+
+       for (i = 0; i < res->clks_num; i++) {
+               core->clks[i] = devm_clk_get(dev, res->clks[i]);
+               if (IS_ERR(core->clks[i]))
+                       return PTR_ERR(core->clks[i]);
+       }
+
+       return 0;
+}
+
+static int venus_clks_enable(struct venus_core *core)
+{
+       const struct venus_resources *res = core->res;
+       unsigned int i;
+       int ret;
+
+       for (i = 0; i < res->clks_num; i++) {
+               ret = clk_prepare_enable(core->clks[i]);
+               if (ret)
+                       goto err;
+       }
+
+       return 0;
+err:
+       while (--i)
+               clk_disable_unprepare(core->clks[i]);
+
+       return ret;
+}
+
+static void venus_clks_disable(struct venus_core *core)
+{
+       const struct venus_resources *res = core->res;
+       unsigned int i;
+
+       for (i = 0; i < res->clks_num; i++)
+               clk_disable_unprepare(core->clks[i]);
+}
+
+static int venus_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct venus_core *core;
+       struct device_node *rproc;
+       struct resource *r;
+       int ret;
+
+       core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);
+       if (!core)
+               return -ENOMEM;
+
+       core->dev = dev;
+       platform_set_drvdata(pdev, core);
+
+       rproc = of_parse_phandle(dev->of_node, "rproc", 0);
+       if (IS_ERR(rproc))
+               return PTR_ERR(rproc);
+
+       core->rproc = rproc_get_by_phandle(rproc->phandle);
+       if (IS_ERR(core->rproc))
+               return PTR_ERR(core->rproc);
+       else if (!core->rproc)
+               return -EPROBE_DEFER;
+
+       r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "base");
+       core->base = devm_ioremap_resource(dev, r);
+       if (IS_ERR(core->base))
+               return PTR_ERR(core->base);
+
+       core->irq = platform_get_irq_byname(pdev, "venus");
+       if (core->irq < 0)
+               return core->irq;
+
+       core->res = of_device_get_match_data(dev);
+       if (!core->res)
+               return -ENODEV;
+
+       ret = venus_clks_get(core);
+       if (ret)
+               return ret;
+
+       ret = dma_set_mask_and_coherent(dev, core->res->dma_mask);
+       if (ret)
+               return ret;
+
+       INIT_LIST_HEAD(&core->instances);
+       mutex_init(&core->lock);
+       INIT_DELAYED_WORK(&core->work, venus_sys_error_handler);
+
+       ret = devm_request_threaded_irq(dev, core->irq, hfi_isr, hfi_isr_thread,
+                                       IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+                                       "venus", core);
+       if (ret)
+               return ret;
+
+       core->core_ops = &venus_core_ops;
+
+       ret = hfi_create(core);
+       if (ret)
+               return ret;
+
+       ret = venus_clks_enable(core);
+       if (ret)
+               goto err_hfi_destroy;
+
+       ret = rproc_boot(core->rproc);
+       if (ret) {
+               venus_clks_disable(core);
+               goto err_hfi_destroy;
+       }
+
+       venus_clks_disable(core);
+
+       pm_runtime_enable(dev);
+
+       ret = pm_runtime_get_sync(dev);
+       if (ret < 0)
+               goto err_runtime_disable;
+
+       ret = hfi_core_init(core);
+       if (ret)
+               goto err_rproc_shutdown;
+
+       ret = pm_runtime_put_sync(dev);
+       if (ret)
+               goto err_core_deinit;
+
+       ret = v4l2_device_register(dev, &core->v4l2_dev);
+       if (ret)
+               goto err_core_deinit;
+
+       core->vdev_dec = video_device_alloc();
+       if (!core->vdev_dec) {
+               ret = -ENOMEM;
+               goto err_dev_unregister;
+       }
+
+       core->vdev_enc = video_device_alloc();
+       if (!core->vdev_enc) {
+               ret = -ENOMEM;
+               goto err_dec_release;
+       }
+
+       ret = vdec_init(core, core->vdev_dec, &venus_fops);
+       if (ret)
+               goto err_enc_release;
+
+       ret = venc_init(core, core->vdev_enc, &venus_fops);
+       if (ret)
+               goto err_vdec_deinit;
+
+       return 0;
+
+err_vdec_deinit:
+       vdec_deinit(core, core->vdev_dec);
+err_enc_release:
+       video_device_release(core->vdev_enc);
+err_dec_release:
+       video_device_release(core->vdev_dec);
+err_dev_unregister:
+       v4l2_device_unregister(&core->v4l2_dev);
+err_core_deinit:
+       hfi_core_deinit(core);
+err_rproc_shutdown:
+       rproc_shutdown(core->rproc);
+err_runtime_disable:
+       pm_runtime_set_suspended(dev);
+       pm_runtime_disable(dev);
+err_hfi_destroy:
+       hfi_destroy(core);
+       return ret;
+}
+
+static int venus_remove(struct platform_device *pdev)
+{
+       struct venus_core *core = platform_get_drvdata(pdev);
+       int ret;
+
+       pm_runtime_get_sync(&pdev->dev);
+
+       ret = hfi_core_deinit(core);
+
+       rproc_shutdown(core->rproc);
+
+       pm_runtime_put_sync(&pdev->dev);
+
+       hfi_destroy(core);
+       vdec_deinit(core, core->vdev_dec);
+       venc_deinit(core, core->vdev_enc);
+       v4l2_device_unregister(&core->v4l2_dev);
+
+       pm_runtime_disable(core->dev);
+
+       return ret;
+}
+
+#ifdef CONFIG_PM
+static int venus_runtime_suspend(struct device *dev)
+{
+       struct venus_core *core = dev_get_drvdata(dev);
+       int ret;
+
+       ret = hfi_core_suspend(core);
+
+       venus_clks_disable(core);
+
+       return ret;
+}
+
+static int venus_runtime_resume(struct device *dev)
+{
+       struct venus_core *core = dev_get_drvdata(dev);
+       int ret;
+
+       ret = venus_clks_enable(core);
+       if (ret)
+               return ret;
+
+       return hfi_core_resume(core);
+}
+#endif
+
+static const struct dev_pm_ops venus_pm_ops = {
+       SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+                               pm_runtime_force_resume)
+       SET_RUNTIME_PM_OPS(venus_runtime_suspend, venus_runtime_resume, NULL)
+};
+
+static const struct freq_tbl msm8916_freq_table[] = {
+       { 352800, 228570000 },  /* 1920x1088 @ 30 + 1280x720 @ 30 */
+       { 244800, 160000000 },  /* 1920x1088 @ 30 */
+       { 108000, 100000000 },  /* 1280x720 @ 30 */
+};
+
+static const struct reg_val msm8916_reg_preset[] = {
+       { 0xe0020, 0x05555556 },
+       { 0xe0024, 0x05555556 },
+       { 0x80124, 0x00000003 },
+};
+
+static const struct venus_resources msm8916_res = {
+       .freq_tbl = msm8916_freq_table,
+       .freq_tbl_size = ARRAY_SIZE(msm8916_freq_table),
+       .reg_tbl = msm8916_reg_preset,
+       .reg_tbl_size = ARRAY_SIZE(msm8916_reg_preset),
+       .clks = { "core", "iface", "bus", },
+       .clks_num = 3,
+       .max_load = 352800, /* 720p@30 + 1080p@30 */
+       .hfi_version = HFI_VERSION_LEGACY,
+       .vmem_id = VIDC_RESOURCE_NONE,
+       .vmem_size = 0,
+       .vmem_addr = 0,
+       .dma_mask = 0xddc00000 - 1,
+};
+
+static const struct freq_tbl msm8996_freq_table[] = {
+       { 1944000, 490000000 }, /* 4k UHD @ 60 */
+       {  972000, 320000000 }, /* 4k UHD @ 30 */
+       {  489600, 150000000 }, /* 1080p @ 60 */
+       {  244800,  75000000 }, /* 1080p @ 30 */
+};
+
+static const struct reg_val msm8996_reg_preset[] = {
+       { 0x80010, 0xffffffff },
+       { 0x80018, 0x00001556 },
+       { 0x8001C, 0x00001556 },
+};
+
+static const struct venus_resources msm8996_res = {
+       .freq_tbl = msm8996_freq_table,
+       .freq_tbl_size = ARRAY_SIZE(msm8996_freq_table),
+       .reg_tbl = msm8996_reg_preset,
+       .reg_tbl_size = ARRAY_SIZE(msm8996_reg_preset),
+       .clks = { "core", "core0", "core1", "iface", "bus", "rpm_mmaxi",
+                 "mmagic_ahb", "mmagic_maxi", "mmagic_video_axi", "maxi" },
+       .clks_num = 10,
+       .max_load = 2563200,
+       .hfi_version = HFI_VERSION_3XX,
+       .vmem_id = VIDC_RESOURCE_NONE,
+       .vmem_size = 0,
+       .vmem_addr = 0,
+       .dma_mask = 0xddc00000 - 1,
+};
+
+static const struct of_device_id venus_dt_match[] = {
+       { .compatible = "qcom,msm8916-venus", .data = &msm8916_res, },
+       { .compatible = "qcom,msm8996-venus", .data = &msm8996_res, },
+       { }
+};
+MODULE_DEVICE_TABLE(of, venus_dt_match);
+
+static struct platform_driver qcom_venus_driver = {
+       .probe = venus_probe,
+       .remove = venus_remove,
+       .driver = {
+               .name = "qcom-venus",
+               .of_match_table = venus_dt_match,
+               .pm = &venus_pm_ops,
+       },
+};
+module_platform_driver(qcom_venus_driver);
+
+MODULE_ALIAS("platform:qcom-venus");
+MODULE_DESCRIPTION("Qualcomm Venus video encoder and decoder driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/platform/qcom/venus/core.h 
b/drivers/media/platform/qcom/venus/core.h
new file mode 100644
index 000000000000..c80aaba29758
--- /dev/null
+++ b/drivers/media/platform/qcom/venus/core.h
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __VENUS_CORE_H_
+#define __VENUS_CORE_H_
+
+#include <linux/list.h>
+#include <media/videobuf2-v4l2.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-device.h>
+
+#include "hfi.h"
+
+#define VIDC_CLKS_NUM_MAX      12
+
+struct freq_tbl {
+       unsigned int load;
+       unsigned long freq;
+};
+
+struct reg_val {
+       u32 reg;
+       u32 value;
+};
+
+struct venus_resources {
+       u64 dma_mask;
+       const struct freq_tbl *freq_tbl;
+       unsigned int freq_tbl_size;
+       const struct reg_val *reg_tbl;
+       unsigned int reg_tbl_size;
+       const char * const clks[VIDC_CLKS_NUM_MAX];
+       unsigned int clks_num;
+       enum hfi_version hfi_version;
+       u32 max_load;
+       unsigned int vmem_id;
+       u32 vmem_size;
+       u32 vmem_addr;
+};
+
+struct venus_format {
+       u32 pixfmt;
+       int num_planes;
+       u32 type;
+};
+
+/**
+ * struct venus_core - holds core parameters valid for all instances
+ *
+ * @base:      IO memory base address
+ * @irq:       Venus irq
+ * @clks:      an array of struct clk pointers
+ * @vdev_dec:  a reference to video device structure for decoder instances
+ * @vdev_enc:  a reference to video device structure for encoder instances
+ * @v4l2_dev:  a holder for v4l2 device structure
+ * @res:               a reference to venus resources structure
+ * @rproc:     a reference to remote processor structure
+ * @dev:               convinience struct device pointer
+ * @lock:      a lock for this strucure
+ * @instances: a list_head of all instances
+ * @state:     the state of the venus core
+ * @done:      a completion for sync HFI operations
+ * @error:     an error returned during last HFI sync operation
+ * @core_ops:  the core operations
+ * @enc_codecs:        encoders supported by this core
+ * @dec_codecs:        decoders supported by this core
+ * @max_sessions_supported:    holds the maximum number of sessions
+ * @core_caps: core capabilities
+ * @priv:      a private filed for HFI operations
+ * @ops:               the core HFI operations
+ * @work:      a delayed work for handling system fatal error
+ */
+struct venus_core {
+       void __iomem *base;
+       int irq;
+       struct clk *clks[VIDC_CLKS_NUM_MAX];
+       struct video_device *vdev_dec;
+       struct video_device *vdev_enc;
+       struct v4l2_device v4l2_dev;
+       const struct venus_resources *res;
+       struct rproc *rproc;
+       struct device *dev;
+       struct mutex lock;
+       struct list_head instances;
+       unsigned int state;
+       struct completion done;
+       unsigned int error;
+       bool sys_error;
+       const struct hfi_core_ops *core_ops;
+       u32 enc_codecs;
+       u32 dec_codecs;
+       unsigned int max_sessions_supported;
+#define ENC_ROTATION_CAPABILITY                0x1
+#define ENC_SCALING_CAPABILITY         0x2
+#define ENC_DEINTERLACE_CAPABILITY     0x4
+#define DEC_MULTI_STREAM_CAPABILITY    0x8
+       unsigned int core_caps;
+       void *priv;
+       const struct hfi_ops *ops;
+       struct delayed_work work;
+};
+
+struct vdec_controls {
+       u32 post_loop_deb_mode;
+       u32 profile;
+       u32 level;
+};
+
+struct venc_controls {
+       u16 gop_size;
+       u32 num_p_frames;
+       u32 num_b_frames;
+       u32 bitrate_mode;
+       u32 bitrate;
+       u32 bitrate_peak;
+
+       u32 h264_i_period;
+       u32 h264_entropy_mode;
+       u32 h264_i_qp;
+       u32 h264_p_qp;
+       u32 h264_b_qp;
+       u32 h264_min_qp;
+       u32 h264_max_qp;
+       u32 h264_loop_filter_mode;
+       u32 h264_loop_filter_alpha;
+       u32 h264_loop_filter_beta;
+
+       u32 vp8_min_qp;
+       u32 vp8_max_qp;
+
+       u32 multi_slice_mode;
+       u32 multi_slice_max_bytes;
+       u32 multi_slice_max_mb;
+
+       u32 header_mode;
+
+       u32 profile;
+       u32 level;
+};
+
+struct venus_buffer {
+       struct vb2_v4l2_buffer vb;
+       struct list_head list;
+       dma_addr_t dma_addr;
+       u32 size;
+       struct list_head reg_list;
+};
+
+#define to_venus_buffer(ptr)   container_of(ptr, struct venus_buffer, vb)
+
+/**
+ * struct venus_inst - holds per instance paramerters
+ *
+ * @list:      used for attach an instance to the core
+ * @lock:      instance lock
+ * @core:      a reference to the core struct
+ * @internalbufs:      a list of internal bufferes
+ * @registeredbufs:    a list of registered capture bufferes
+ * @ctrl_handler:      v4l control handler
+ * @controls:  an union of decoder and encoder control parameters
+ * @fh:         a holder of v4l file handle structure
+ * @width:     current capture width
+ * @height:    current capture height
+ * @out_width: current output width
+ * @out_height:        current output height
+ * @colorspace:        current color space
+ * @quantization:      current quantization
+ * @xfer_func: current xfer function
+ * @fps:               holds current FPS
+ * @timeperframe:      holds current time per frame structure
+ * @fmt_out:   a reference to output format structure
+ * @fmt_cap:   a reference to capture format structure
+ * @num_input_bufs:    holds number of input buffers
+ * @num_output_bufs:   holds number of output buffers
+ * @input_buf_size     holds input buffer size
+ * @output_buf_size:   holds output buffer size
+ * @reconfig:  a flag raised by decoder when the stream resolution changed
+ * @reconfig_width:    holds the new width
+ * @reconfig_height:   holds the new height
+ * @sequence:          a sequence counter
+ * @codec_cfg: a flag used to annonce a codec configuration
+ * @m2m_dev:   a reference to m2m device structure
+ * @m2m_ctx:   a reference to m2m context structure
+ * @state:     current state of the instance
+ * @done:      a completion for sync HFI operation
+ * @error:     an error returned during last HFI sync operation
+ * @session_error:     a flag rised by HFI interface in case of session error
+ * @ops:               HFI operations
+ * @priv:      a private for HFI operations callbacks
+ * @session_type:      the type of the session (decoder or encoder)
+ * @hprop:     an union used as a holder by get property
+ * @cap_width: width capability
+ * @cap_height:        height capability
+ * @cap_mbs_per_frame: macroblocks per frame capability
+ * @cap_mbs_per_sec:   macroblocks per second capability
+ * @cap_framerate:     framerate capability
+ * @cap_scale_x:               horizontal scaling capability
+ * @cap_scale_y:               vertical scaling capability
+ * @cap_bitrate:               bitrate capability
+ * @cap_hier_p:                hier capability
+ * @cap_ltr_count:     LTR count capability
+ * @cap_secure_output2_threshold: secure OUTPUT2 threshold capability
+ * @cap_bufs_mode_static:      buffers allocation mode capability
+ * @cap_bufs_mode_dynamic:     buffers allocation mode capability
+ * @pl_count:  count of supported profiles/levels
+ * @pl:                supported profiles/levels
+ * @bufreq:    holds buffer requirements
+ */
+struct venus_inst {
+       struct list_head list;
+       struct mutex lock;
+       struct venus_core *core;
+       struct list_head internalbufs;
+       struct list_head registeredbufs;
+
+       struct v4l2_ctrl_handler ctrl_handler;
+       union {
+               struct vdec_controls dec;
+               struct venc_controls enc;
+       } controls;
+       struct v4l2_fh fh;
+       unsigned streamon_cap, streamon_out;
+       u32 width;
+       u32 height;
+       u32 out_width;
+       u32 out_height;
+       u32 colorspace;
+       u8 ycbcr_enc;
+       u8 quantization;
+       u8 xfer_func;
+       u64 fps;
+       struct v4l2_fract timeperframe;
+       const struct venus_format *fmt_out;
+       const struct venus_format *fmt_cap;
+       unsigned int num_input_bufs;
+       unsigned int num_output_bufs;
+       unsigned int input_buf_size;
+       unsigned int output_buf_size;
+       bool reconfig;
+       u32 reconfig_width;
+       u32 reconfig_height;
+       u64 sequence;
+       bool codec_cfg;
+       struct v4l2_m2m_dev *m2m_dev;
+       struct v4l2_m2m_ctx *m2m_ctx;
+       unsigned int state;
+       struct completion done;
+       unsigned int error;
+       bool session_error;
+       const struct hfi_inst_ops *ops;
+       u32 session_type;
+       union hfi_get_property hprop;
+       struct hfi_capability cap_width;
+       struct hfi_capability cap_height;
+       struct hfi_capability cap_mbs_per_frame;
+       struct hfi_capability cap_mbs_per_sec;
+       struct hfi_capability cap_framerate;
+       struct hfi_capability cap_scale_x;
+       struct hfi_capability cap_scale_y;
+       struct hfi_capability cap_bitrate;
+       struct hfi_capability cap_hier_p;
+       struct hfi_capability cap_ltr_count;
+       struct hfi_capability cap_secure_output2_threshold;
+       bool cap_bufs_mode_static;
+       bool cap_bufs_mode_dynamic;
+       unsigned int pl_count;
+       struct hfi_profile_level pl[HFI_MAX_PROFILE_COUNT];
+       struct hfi_buffer_requirements bufreq[HFI_BUFFER_TYPE_MAX];
+};
+
+#define ctrl_to_inst(ctrl)     \
+       container_of(ctrl->handler, struct venus_inst, ctrl_handler)
+
+static inline struct venus_inst *to_inst(struct file *filp)
+{
+       return container_of(filp->private_data, struct venus_inst, fh);
+}
+
+static inline void *to_hfi_priv(struct venus_core *core)
+{
+       return core->priv;
+}
+
+#endif
diff --git a/drivers/media/platform/qcom/venus/helpers.c 
b/drivers/media/platform/qcom/venus/helpers.c
new file mode 100644
index 000000000000..fed3a8bd719a
--- /dev/null
+++ b/drivers/media/platform/qcom/venus/helpers.c
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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/clk.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <media/videobuf2-dma-sg.h>
+#include <media/v4l2-mem2mem.h>
+
+#include "core.h"
+#include "helpers.h"
+#include "hfi_helper.h"
+
+struct intbuf {
+       struct list_head list;
+       u32 type;
+       size_t size;
+       void *va;
+       dma_addr_t da;
+       unsigned long attrs;
+};
+
+static int intbufs_set_buffer(struct venus_inst *inst, u32 type)
+{
+       struct venus_core *core = inst->core;
+       struct device *dev = core->dev;
+       struct hfi_buffer_requirements bufreq;
+       struct hfi_buffer_desc bd;
+       struct intbuf *buf;
+       unsigned int i;
+       int ret;
+
+       ret = helper_get_bufreq(inst, type, &bufreq);
+       if (ret)
+               return 0;
+
+       if (!bufreq.size)
+               return 0;
+
+       for (i = 0; i < bufreq.count_actual; i++) {
+               buf = kzalloc(sizeof(*buf), GFP_KERNEL);
+               if (!buf) {
+                       ret = -ENOMEM;
+                       goto fail;
+               }
+
+               buf->type = bufreq.type;
+               buf->size = bufreq.size;
+               buf->attrs = DMA_ATTR_WRITE_COMBINE |
+                            DMA_ATTR_NO_KERNEL_MAPPING;
+               buf->va = dma_alloc_attrs(dev, buf->size, &buf->da, GFP_KERNEL,
+                                         buf->attrs);
+               if (!buf->va) {
+                       ret = -ENOMEM;
+                       goto fail;
+               }
+
+               memset(&bd, 0, sizeof(bd));
+               bd.buffer_size = buf->size;
+               bd.buffer_type = buf->type;
+               bd.num_buffers = 1;
+               bd.device_addr = buf->da;
+
+               ret = hfi_session_set_buffers(inst, &bd);
+               if (ret) {
+                       dev_err(dev, "set session buffers failed\n");
+                       goto dma_free;
+               }
+
+               list_add_tail(&buf->list, &inst->internalbufs);
+       }
+
+       return 0;
+
+dma_free:
+       dma_free_attrs(dev, buf->size, buf->va, buf->da, buf->attrs);
+fail:
+       kfree(buf);
+       return ret;
+}
+
+static int intbufs_unset_buffers(struct venus_inst *inst)
+{
+       struct hfi_buffer_desc bd = {0};
+       struct intbuf *buf, *n;
+       int ret = 0;
+
+       list_for_each_entry_safe(buf, n, &inst->internalbufs, list) {
+               bd.buffer_size = buf->size;
+               bd.buffer_type = buf->type;
+               bd.num_buffers = 1;
+               bd.device_addr = buf->da;
+               bd.response_required = true;
+
+               ret = hfi_session_unset_buffers(inst, &bd);
+
+               list_del(&buf->list);
+               dma_free_attrs(inst->core->dev, buf->size, buf->va, buf->da,
+                              buf->attrs);
+               kfree(buf);
+       }
+
+       return ret;
+}
+
+static const unsigned int intbuf_types[] = {
+       HFI_BUFFER_INTERNAL_SCRATCH,
+       HFI_BUFFER_INTERNAL_SCRATCH_1,
+       HFI_BUFFER_INTERNAL_SCRATCH_2,
+       HFI_BUFFER_INTERNAL_PERSIST,
+       HFI_BUFFER_INTERNAL_PERSIST_1,
+};
+
+static int intbufs_alloc(struct venus_inst *inst)
+{
+       unsigned int i;
+       int ret;
+
+       for (i = 0; i < ARRAY_SIZE(intbuf_types); i++) {
+               ret = intbufs_set_buffer(inst, intbuf_types[i]);
+               if (ret)
+                       goto error;
+       }
+
+       return 0;
+
+error:
+       intbufs_unset_buffers(inst);
+       return ret;
+}
+
+static int intbufs_free(struct venus_inst *inst)
+{
+       return intbufs_unset_buffers(inst);
+}
+
+static u32 load_per_instance(struct venus_inst *inst)
+{
+       u32 w = inst->width;
+       u32 h = inst->height;
+       u32 mbs;
+
+       if (!inst || !(inst->state >= INST_INIT && inst->state < INST_STOP))
+               return 0;
+
+       mbs = (ALIGN(w, 16) / 16) * (ALIGN(h, 16) / 16);
+
+       return mbs * inst->fps;
+}
+
+static u32 load_per_type(struct venus_core *core, u32 session_type)
+{
+       struct venus_inst *inst = NULL;
+       u32 mbs_per_sec = 0;
+
+       mutex_lock(&core->lock);
+       list_for_each_entry(inst, &core->instances, list) {
+               if (inst->session_type != session_type)
+                       continue;
+
+               mbs_per_sec += load_per_instance(inst);
+       }
+       mutex_unlock(&core->lock);
+
+       return mbs_per_sec;
+}
+
+static int load_scale_clocks(struct venus_core *core)
+{
+       const struct freq_tbl *table = core->res->freq_tbl;
+       unsigned int num_rows = core->res->freq_tbl_size;
+       unsigned long freq = table[0].freq;
+       struct clk *clk = core->clks[0];
+       struct device *dev = core->dev;
+       u32 mbs_per_sec;
+       unsigned int i;
+       int ret;
+
+       mbs_per_sec = load_per_type(core, VIDC_SESSION_TYPE_ENC) +
+                     load_per_type(core, VIDC_SESSION_TYPE_DEC);
+
+       if (mbs_per_sec > core->res->max_load) {
+               dev_warn(dev, "HW is overloaded, needed: %d max: %d\n",
+                        mbs_per_sec, core->res->max_load);
+               return -EBUSY;
+       }
+
+       if (!mbs_per_sec && num_rows > 1) {
+               freq = table[num_rows - 1].freq;
+               goto set_freq;
+       }
+
+       for (i = 0; i < num_rows; i++) {
+               if (mbs_per_sec > table[i].load)
+                       break;
+               freq = table[i].freq;
+       }
+
+set_freq:
+
+       ret = clk_set_rate(clk, freq);
+       if (ret) {
+               dev_err(dev, "failed to set clock rate %lu (%d)\n", freq, ret);
+               return ret;
+       }
+
+       return 0;
+}
+
+static void fill_buffer_desc(const struct venus_buffer *buf,
+                            struct hfi_buffer_desc *bd, bool response)
+{
+       memset(bd, 0, sizeof(*bd));
+       bd->buffer_type = HFI_BUFFER_OUTPUT;
+       bd->buffer_size = buf->size;
+       bd->num_buffers = 1;
+       bd->device_addr = buf->dma_addr;
+       bd->response_required = response;
+}
+
+static void return_buf_error(struct venus_inst *inst,
+                            struct vb2_v4l2_buffer *vbuf)
+{
+       struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
+
+       if (vbuf->vb2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+               v4l2_m2m_src_buf_remove_exact(m2m_ctx, vbuf);
+       else
+               v4l2_m2m_dst_buf_remove_exact(m2m_ctx, vbuf);
+
+       v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
+}
+
+static int
+session_process_buf(struct venus_inst *inst, struct vb2_v4l2_buffer *vbuf)
+{
+       struct venus_buffer *buf = to_venus_buffer(vbuf);
+       struct vb2_buffer *vb = &vbuf->vb2_buf;
+       struct venus_core *core = inst->core;
+       struct device *dev = core->dev;
+       unsigned int type = vb->type;
+       struct hfi_frame_data fdata;
+       int ret;
+
+       memset(&fdata, 0, sizeof(fdata));
+       fdata.alloc_len = buf->size;
+       fdata.device_addr = buf->dma_addr;
+       fdata.timestamp = vb->timestamp;
+       fdata.flags = 0;
+       fdata.clnt_data = vbuf->vb2_buf.index;
+
+       if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+               fdata.buffer_type = HFI_BUFFER_INPUT;
+               fdata.filled_len = vb2_get_plane_payload(vb, 0);
+               fdata.offset = vb->planes[0].data_offset;
+
+               if (vbuf->flags & V4L2_BUF_FLAG_LAST || !fdata.filled_len)
+                       fdata.flags |= HFI_BUFFERFLAG_EOS;
+
+               if (inst->codec_cfg == false &&
+                   inst->session_type == VIDC_SESSION_TYPE_DEC) {
+                       inst->codec_cfg = true;
+                       fdata.flags |= HFI_BUFFERFLAG_CODECCONFIG;
+               }
+       } else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
+               fdata.buffer_type = HFI_BUFFER_OUTPUT;
+               fdata.filled_len = 0;
+               fdata.offset = 0;
+       }
+
+       ret = hfi_session_process_buf(inst, &fdata);
+       if (ret) {
+               dev_err(dev, "process buffer failed (%d)\n", ret);
+               return ret;
+       }
+
+       return 0;
+}
+
+static int session_unregister_bufs(struct venus_inst *inst)
+{
+       struct venus_core *core = inst->core;
+       struct device *dev = core->dev;
+       struct hfi_buffer_desc bd;
+       struct venus_buffer *buf, *n;
+       int ret = 0;
+
+       if (core->res->hfi_version == HFI_VERSION_3XX)
+               return 0;
+
+       list_for_each_entry_safe(buf, n, &inst->registeredbufs, reg_list) {
+               fill_buffer_desc(buf, &bd, true);
+               ret = hfi_session_unset_buffers(inst, &bd);
+               if (ret)
+                       dev_err(dev, "%s: unset buffers failed\n", __func__);
+
+               list_del(&buf->reg_list);
+       }
+
+       return ret;
+}
+
+static int session_register_bufs(struct venus_inst *inst)
+{
+       struct venus_core *core = inst->core;
+       struct device *dev = core->dev;
+       struct hfi_buffer_desc bd;
+       struct venus_buffer *buf;
+       int ret = 0;
+
+       if (core->res->hfi_version == HFI_VERSION_3XX)
+               return 0;
+
+       list_for_each_entry(buf, &inst->registeredbufs, reg_list) {
+               fill_buffer_desc(buf, &bd, false);
+               ret = hfi_session_set_buffers(inst, &bd);
+               if (ret) {
+                       dev_err(dev, "%s: session: set buffer failed\n",
+                               __func__);
+                       break;
+               }
+       }
+
+       return ret;
+}
+
+int helper_get_bufreq(struct venus_inst *inst, u32 type,
+                     struct hfi_buffer_requirements *req)
+{
+       u32 ptype = HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS;
+       union hfi_get_property hprop;
+       int ret, i;
+
+       if (req)
+               memset(req, 0, sizeof(*req));
+
+       ret = hfi_session_get_property(inst, ptype, &hprop);
+       if (ret)
+               return ret;
+
+       ret = -EINVAL;
+
+       for (i = 0; i < HFI_BUFFER_TYPE_MAX; i++) {
+               if (hprop.bufreq[i].type != type)
+                       continue;
+
+               if (req)
+                       memcpy(req, &hprop.bufreq[i], sizeof(*req));
+               ret = 0;
+               break;
+       }
+
+       return ret;
+}
+
+int helper_set_input_resolution(struct venus_inst *inst, unsigned int width,
+                               unsigned int height)
+{
+       u32 ptype = HFI_PROPERTY_PARAM_FRAME_SIZE;
+       struct hfi_framesize fs;
+
+       fs.buffer_type = HFI_BUFFER_INPUT;
+       fs.width = width;
+       fs.height = height;
+
+       return hfi_session_set_property(inst, ptype, &fs);
+}
+
+int helper_set_output_resolution(struct venus_inst *inst, unsigned int width,
+                                unsigned int height)
+{
+       u32 ptype = HFI_PROPERTY_PARAM_FRAME_SIZE;
+       struct hfi_framesize fs;
+
+       fs.buffer_type = HFI_BUFFER_OUTPUT;
+       fs.width = width;
+       fs.height = height;
+
+       return hfi_session_set_property(inst, ptype, &fs);
+}
+
+int helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs,
+                       unsigned int output_bufs)
+{
+       u32 ptype = HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL;
+       struct hfi_buffer_count_actual buf_count;
+       int ret;
+
+       buf_count.type = HFI_BUFFER_INPUT;
+       buf_count.count_actual = input_bufs;
+
+       ret = hfi_session_set_property(inst, ptype, &buf_count);
+       if (ret)
+               return ret;
+
+       buf_count.type = HFI_BUFFER_OUTPUT;
+       buf_count.count_actual = output_bufs;
+
+       return hfi_session_set_property(inst, ptype, &buf_count);
+}
+
+int helper_set_color_format(struct venus_inst *inst, u32 pixfmt)
+{
+       struct hfi_uncompressed_format_select fmt;
+       u32 ptype = HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT;
+       int ret;
+
+       if (inst->session_type == VIDC_SESSION_TYPE_DEC)
+               fmt.buffer_type = HFI_BUFFER_OUTPUT;
+       else if (inst->session_type == VIDC_SESSION_TYPE_ENC)
+               fmt.buffer_type = HFI_BUFFER_INPUT;
+       else
+               return -EINVAL;
+
+       switch (pixfmt) {
+       case V4L2_PIX_FMT_NV12:
+               fmt.format = HFI_COLOR_FORMAT_NV12;
+               break;
+       case V4L2_PIX_FMT_NV21:
+               fmt.format = HFI_COLOR_FORMAT_NV21;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       ret = hfi_session_set_property(inst, ptype, &fmt);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+
+struct vb2_v4l2_buffer *
+helper_find_buf(struct venus_inst *inst, unsigned int type, u32 idx)
+{
+       struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
+
+       if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+               return v4l2_m2m_src_buf_remove_by_idx(m2m_ctx, idx);
+       else
+               return v4l2_m2m_dst_buf_remove_by_idx(m2m_ctx, idx);
+}
+
+int helper_vb2_buf_init(struct vb2_buffer *vb)
+{
+       struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
+       struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
+       struct venus_buffer *buf = to_venus_buffer(vbuf);
+       struct sg_table *sgt;
+
+       sgt = vb2_dma_sg_plane_desc(vb, 0);
+       if (!sgt)
+               return -EFAULT;
+
+       buf->size = vb2_plane_size(vb, 0);
+       buf->dma_addr = sg_dma_address(sgt->sgl);
+
+       if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
+               list_add_tail(&buf->reg_list, &inst->registeredbufs);
+
+       return 0;
+}
+
+int helper_vb2_buf_prepare(struct vb2_buffer *vb)
+{
+       struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
+
+       if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
+           vb2_plane_size(vb, 0) < inst->output_buf_size)
+               return -EINVAL;
+       else if (vb2_plane_size(vb, 0) < inst->input_buf_size)
+               return -EINVAL;
+
+       return 0;
+}
+
+void helper_vb2_buf_queue(struct vb2_buffer *vb)
+{
+       struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
+       struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
+       struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
+       int ret;
+
+       mutex_lock(&inst->lock);
+
+       v4l2_m2m_buf_queue(m2m_ctx, vbuf);
+
+       if (!(inst->streamon_out & inst->streamon_cap))
+               goto unlock;
+
+       ret = session_process_buf(inst, vbuf);
+       if (ret)
+               return_buf_error(inst, vbuf);
+
+unlock:
+       mutex_unlock(&inst->lock);
+}
+
+void helper_buffers_done(struct venus_inst *inst, enum vb2_buffer_state state)
+{
+       struct vb2_v4l2_buffer *buf;
+
+       while ((buf = v4l2_m2m_src_buf_remove(inst->m2m_ctx)))
+               v4l2_m2m_buf_done(buf, state);
+       while ((buf = v4l2_m2m_dst_buf_remove(inst->m2m_ctx)))
+               v4l2_m2m_buf_done(buf, state);
+}
+
+void helper_vb2_stop_streaming(struct vb2_queue *q)
+{
+       struct venus_inst *inst = vb2_get_drv_priv(q);
+       struct venus_core *core = inst->core;
+       struct device *dev = core->dev;
+       int ret;
+
+       mutex_lock(&inst->lock);
+
+       if (inst->streamon_out & inst->streamon_cap) {
+               ret = hfi_session_stop(inst);
+               ret |= hfi_session_unload_res(inst);
+               ret |= session_unregister_bufs(inst);
+               ret |= intbufs_free(inst);
+               ret |= hfi_session_deinit(inst);
+
+               if (inst->session_error || core->sys_error)
+                       ret = -EIO;
+
+               if (ret)
+                       hfi_session_abort(inst);
+
+               load_scale_clocks(core);
+               pm_runtime_put_sync(dev);
+       }
+
+       helper_buffers_done(inst, VB2_BUF_STATE_ERROR);
+
+       if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+               inst->streamon_out = 0;
+       else
+               inst->streamon_cap = 0;
+
+       mutex_unlock(&inst->lock);
+}
+
+int helper_vb2_start_streaming(struct venus_inst *inst)
+{
+       struct venus_core *core = inst->core;
+       int ret;
+
+       ret = intbufs_alloc(inst);
+       if (ret)
+               return ret;
+
+       ret = session_register_bufs(inst);
+       if (ret)
+               goto err_bufs_free;
+
+       load_scale_clocks(core);
+
+       ret = hfi_session_load_res(inst);
+       if (ret)
+               goto err_unreg_bufs;
+
+       ret = hfi_session_start(inst);
+       if (ret)
+               goto err_unload_res;
+
+       return 0;
+
+err_unload_res:
+       hfi_session_unload_res(inst);
+err_unreg_bufs:
+       session_unregister_bufs(inst);
+err_bufs_free:
+       intbufs_free(inst);
+       return ret;
+}
+
+void helper_m2m_device_run(void *priv)
+{
+       struct venus_inst *inst = priv;
+       struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
+       struct v4l2_m2m_buffer *buf, *n;
+       int ret;
+
+       mutex_lock(&inst->lock);
+
+       v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, buf, n) {
+               ret = session_process_buf(inst, &buf->vb);
+               if (ret)
+                       return_buf_error(inst, &buf->vb);
+       }
+
+       v4l2_m2m_for_each_src_buf_safe(m2m_ctx, buf, n) {
+               ret = session_process_buf(inst, &buf->vb);
+               if (ret)
+                       return_buf_error(inst, &buf->vb);
+       }
+
+       mutex_unlock(&inst->lock);
+}
+
+void helper_m2m_job_abort(void *priv)
+{
+       struct venus_inst *inst = priv;
+
+       v4l2_m2m_job_finish(inst->m2m_dev, inst->m2m_ctx);
+}
diff --git a/drivers/media/platform/qcom/venus/helpers.h 
b/drivers/media/platform/qcom/venus/helpers.h
new file mode 100644
index 000000000000..123e06eab4c2
--- /dev/null
+++ b/drivers/media/platform/qcom/venus/helpers.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ */
+#ifndef __VENUS_HELPERS_H__
+#define __VENUS_HELPERS_H__
+
+#include <media/videobuf2-v4l2.h>
+
+struct venus_inst;
+
+struct vb2_v4l2_buffer *helper_find_buf(struct venus_inst *inst,
+                                       unsigned int type, u32 idx);
+void helper_buffers_done(struct venus_inst *inst, enum vb2_buffer_state state);
+int helper_vb2_buf_init(struct vb2_buffer *vb);
+int helper_vb2_buf_prepare(struct vb2_buffer *vb);
+void helper_vb2_buf_queue(struct vb2_buffer *vb);
+void helper_vb2_stop_streaming(struct vb2_queue *q);
+int helper_vb2_start_streaming(struct venus_inst *inst);
+void helper_m2m_device_run(void *priv);
+void helper_m2m_job_abort(void *priv);
+int helper_get_bufreq(struct venus_inst *inst, u32 type,
+                     struct hfi_buffer_requirements *req);
+int helper_set_input_resolution(struct venus_inst *inst, unsigned int width,
+                               unsigned int height);
+int helper_set_output_resolution(struct venus_inst *inst, unsigned int width,
+                                unsigned int height);
+int helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs,
+                       unsigned int output_bufs);
+int helper_set_color_format(struct venus_inst *inst, u32 fmt);
+#endif
-- 
2.7.4

Reply via email to