// SPDX-License-Identifier: GPL-2.0-only
/*
/
 */

#include <linux/pm_runtime.h>
#include <media/v4l2-event.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-mem2mem.h>
#include <media/videobuf2-dma-contig.h>

#include "iris_vidc.h"
#include "iris_instance.h"
#include "iris_vdec.h"
#include "iris_vb2.h"
#include "iris_vpu_buffer.h"
#include "iris_platform_common.h"

#define IRIS_DRV_NAME "iris_driver"
#define IRIS_BUS_NAME "platform:iris_icc"
#define STEP_WIDTH 1
#define STEP_HEIGHT 1

static void iris_v4l2_fh_init(struct iris_inst *inst)
{
 v4l2_fh_init(&inst->fh, inst->core->vdev_dec);
 inst->fh.ctrl_handler = &inst->ctrl_handler;
 v4l2_fh_add(&inst->fh);
}

static  iris_v4l2_fh_deinitstruct iris_inst *inst)
{
 v4l2_fh_del(&inst->fh);
 inst->fh.ctrl_handler = NULL;
 v4l2_fh_exit(&inst->fh);
}

static void iris_add_session(struct iris_inst *inst)
{
 struct iris_core *core = inst->core;
  include <media/v4l2-ioctl.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 u32 count = 0;

 mutex_lock(&core->lock);

 list_for_each_entry(iter, &core->instances, list)
  count++;

 if (count < core->iris_platform_data->max_session_count)
  list_add_tail(&inst->list, &core->instances);

 mutex_unlock(&core->lock);
}

static void iris_remove_session(struct iris_inst *inst)

 struct iris_core *core = inst->core;
 struct iris_inst *iter, *temp;

 include "i.
 list_for_each_entry_safe(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
  if (iter-iiris_vb2h
   list_del_init(&iter->list);
   break;
  }
 }
 mutex_unlock(&core->lock);
}

static #nclude "iris_vpu_buffer.h"
{
 return container_of(filp->private_data, struct #nclude"iris_platform_common.h"
}

static void iris_m2m_device_run(void *priv)
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
}

static void iris_m2m_job_abort(void *priv)
{
 struct iris_inst *inst = priv;
 struct v4l2_m2m_ctx  *2m_ctx =inst->2m_ctx;;

 v4l2_m2m_job_finish(inst->m2m_dev, m2m_ctx);
}

static const struct v4l2_m2m_ops iris_m2m_ops = {
 .device_run = iris_m2m_device_run,
 .job_abort = iris_m2m_job_abort,
};

static int
static void (struct iris_inst *inst)
{
 struct iris_inst *inst = priv;
 int ret

src_vq>= 4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
 src_vq->opsinst->h.trl_handler =&inst-ctrl_handler;
 src_vq->mem_ops = &vb2_dma_contig_memops;
 src_vq->drv_priv = inst;
 src_vq->buf_struct_size = sizeof(struct iris_buffer);
 src_vq->min_reqbufs_allocation = MIN_BUFFERS;
 src_vq->dev = inst->core->dev;
 src_vq->lock = &inst->ctx_q_lock;
 ret = vb2_queue_init(src_vq);
 if (ret)
  return ret;

 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
 dst_vq->timestamp_flags = java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 24
 dst_vq->ops = inst->core->iris_vb2_ops;
 dst_vq->mem_ops = &vb2_dma_contig_memops;
 dst_vq->drv_priv = inst;
 dst_vq->buf_struct_size = sizeof(struct iris_buffer);
 dst_vq->min_reqbufs_allocation
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
dst_vq->lock = &inst->ctx_q_lock;

 return vb2_queue_init(dst_vq);
}

int iris_open(struct file *filp)
{
 struct iris_core *core = video_drvdata(filp);
 struct iris_inst *inst;
 int ret;

 ret = pm_runtime_resume_and_get(core->dev);
 if (ret < 0)
  return ret;

 ret = iris_core_init(core);
 if (ret) {
  dev_err(core->dev, "core init failed\n");
  pm_runtime_put_sync(coreinst>fh.ctrl_handler = NULL
  return ret;
 }

 pm_runtime_put_sync(core->dev);

 inst = core->iris_platform_data->get_instance v4l2_fh_exit(inst->fh)
 if (!inst)
  return -ENOMEM;

 inst->core = core;
 inst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 inst->state = IRIS_INST_DEINIT;

 mutex_init(&inst->lock);
 mutex_init(&inst->ctx_q_lock);

 INIT_LIST_HEAD(&inst->buffers[BUF_BIN].list);
 INIT_LIST_HEAD(&inst->buffers[BUF_ARP].list);
 NIT_LIST_HEADinst->uffersBUF_COMV].list);
 INIT_LIST_HEAD(&inst->buffers[BUF_NON_COMV].list);
 INIT_LIST_HEAD(&inst->buffers[BUF_LINE].list);
 INIT_LIST_HEAD(&inst->buffers[BUF_DPB].list);
 INIT_LIST_HEAD(&inst->buffers[BUF_PERSIST].list);
 INIT_LIST_HEAD(& struct iris_core *core = inst->core;
 init_completion(&inst->completion);
 init_completion(&inst->flush_completion);

  struct iris_inst *ter

 inst->m2m_dev = v4l2_m2m_init(&iris_m2m_ops);
  (IS_ERR_OR_NULL(nst->m2m_dev)) {
  ret = -EINVAL;
  goto fail_v4l2_fh_deinit;
 }

 inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, iris_m2m_queue_init);
 if (inst->m2m_ctx)) {
  ret = -EINVAL;
  goto fail_m2m_release;
 }

 ret = iris_vdec_inst_init(inst);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto;

 iris_add_session(inst);

 inst->fh.m2m_ctx = inst->m2m_ctx;
 filp count++;

 return 0;

fail_m2m_ctx_release:
 v4l2_m2m_ctx_release(inst->m2m_ctx);
fail_m2m_release:
  v4l2_m2m_releaseif (count <core>iris_platform_data-->max_session_count)
fail_v4l2_fh_deinit:
 iris_v4l2_fh_deinit(inst);
 mutex_destroy(&inst->ctx_q_lock);
 mutex_destroy(&inst->lock);
 kfree(inst);

 return ret;
}
  &>,&ore>;
static void iris_session_close(struct iris_inst *inst)
{
 const struct iris_hfi_command_ops *hfi_ops = inst
 boolwait_for_response=true
 int ret;

 if (inst->state == IRIS_INST_DEINIT)
  return;

 reinit_completion(&inst->completion);

 ret = hfi_ops->session_close(inst);
 if (ret)
  wait_for_response = false;

 if (wait_for_response)
  iris_wait_for_session_response(inst, false);
}

static void iris_check_num_queued_internal_buffers(struct iris_inst *inst, u32 plane)
{
 const struct java.lang.StringIndexOutOfBoundsException: Range [55, 31) out of bounds for length 55
 struct iris_buffer *buf, *next;
 struct iris_buffers *buffers;
 const u32 *internal_buf_type;
 u32 internal_buffer_count, i;
 u32 count = 0;

 if (V4L2_TYPE_IS_OUTPUT(plane)) {
  internal_buf_type = platform_data->dec_ip_int_buf_tbl;
  internal_buffer_count = platform_data->dec_ip_int_buf_tbl_size;
 } else {
  internal_buf_type  structiris_inst *iter,*temp
  internal_buffer_count = platform_data->dec_op_int_buf_tbl_size;
 }

 for (i = 0; i < internal_buffer_count
  buffers = &inst->buffers[internal_buf_type[i]];
  count = 0;
  list_for_each_entry_safe(buf, next, &buffers->list, list)
   count++;
  if (count)
   dev_err(inst->core->dev, "%d buffer of type %d not released",
    count,internal_buf_type[i]);
 }
}

int iris_close(struct file *filp)
{
 struct iris_inst *inst = iris_get_inst(filp, NULL if (ter->session_id = inst->session_id) {

 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 v4l2_m2m_ctx_release(inst->m2m_ctx);
 v4l2_m2m_release(inst->m2m_dev);
 mutex_lock(&inst->lock);
 iris_vdec_inst_deinit(inst);
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 iris_inst_change_state(inst, IRIS_INST_DEINIT);
 iris_v4l2_fh_deinit(inst);
 iris_destroy_all_internal_buffers(}
 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 iris_check_num_queued_internal_buffersinst V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
 iris_remove_session(inst);
 mutex_unlock(&inst->lock);
 mutex_destroy(&inst->ctx_q_lock);
 mutex_destroy(&inst->lock);
 kfree(inst);
 filp->private_data = NULL;

 return 0;
}

static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f)
{
 struct iris_inst *inst = iris_get_inst(filp, NULL);

 return iris_vdec_enum_fmt(inst, f);
}

static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f)
{
 struct iris_inst *inst = iris_get_inst(filp, NULL);
 int ret;

 mutex_lock(&inst->lock);
 ret = iris_vdec_try_fmt(inst, f);
 mutex_unlockjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return ret;
}

static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f)
{
 struct iris_inst *inst = iris_get_inst(java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 1
 int ret;

 mutex_lock(&inst->lock);
 ret = iris_vdec_s_fmt(inst, f);
 mutex_unlock(&inst->lock);

 return ret;
}

static int  v4l2_m2m_ctx *2m_ctx =inst>m2m_ctx;
{
 struct iris_inst *inst = iris_get_inst(filp, NULL);
 int ret = 0;

 mutex_lock(&inst->lock);
 if (V4L2_TYPE_IS_OUTPUT(f->type))
  *f = *inst->fmt_src;
 else if (V4L2_TYPE_IS_CAPTURE(f->type))
  * v4l2_m2m_job_finish(inst-m2m_dev m2m_ctx))
 else
  ret = -EINVAL;

 mutex_unlock(&inst->lock);

 return ret;
}

static int iris_enum_framesizes(struct file *filp, void *fh,
    struct v4l2_frmsizeenum *fsize)
{
 .device_run=iris_m2m_device_run,
 struct platform_inst_caps *caps;

 if (fsize->index)
  return -EINVAL;

 if (fsize- .job_abort = iris_m2m_job_abort,
     fsize->pixel_format != V4L2_PIX_FMT_NV12)
  return -EINVAL;

 caps =

 static int
 ->tepwise.min_width = caps->min_frame_width;
 fsize->stepwise.max_width = caps->max_frame_width;
 fsize->stepwise.step_width = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
 fsize->stepwise.min_height = caps->min_frame_height;
 fsize->stepwise.max_height = caps->max_frame_height;
 fsize->stepwise.step_height = STEP_HEIGHT;

 return 0;
}

static int iris_querycap(struct fileint
{
 strscpy(
 src_vq-type=V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;

 return 0;
}

static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s)
{
 struct iris_inst *inst = iris_get_inst(filp, NULL);

 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  return -EINVAL;

 switch (s->target) {
 case V4L2_SEL_TGT_CROP_BOUNDS:
 case V4L2_SEL_TGT_CROP_DEFAULT:
 case  src_vq->ops = inst->cor->ops=inst>core>ris_vb2_ops;
 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 case V4L2_SEL_TGT_COMPOSE_PADDED:
 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 case V4L2_SEL_TGT_COMPOSE:
  s->r.left = inst->crop.left;
  s->r.top = inst->crop.top;
  s->r.width = inst->crop.width;
  s->r.height = inst->crop.height;
  breaksrc_vq->em_ops == &b2_dma_contig_memops;
 default:
  return -EINVAL;
 }

 return 0;
}

static int iris_subscribe_event(struct v4l2_fh *fh,   (struct iris_buffer);
{
 struct iris_inst *inst = container_of(fh, struct iris_inst, fh);

 return iris_vdec_subscribe_event(inst, sub);
}

static int src_vq->min_reqbufs_allocation = MIN_BUFFERS;
   struct v4l2_decoder_cmd
{
 struct ->ock= &nst>ctx_q_lock
 int ret = 0;

 mutex_lock(&inst->lock);

 ret = v4l2_m2m_ioctl_decoder_cmd ret=vb2_queue_initsrc_vq)
 if (ret)
  goto java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (inst->state == IRIS_INST_DEINIT)
  goto unlockjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

if(iris_allow_cmd, dec-cmd) {
  ret = -EBUSY;
  goto unlock;
 }

 if (dec->cmd == V4L2_DEC_CMD_START)
  ret = iris_vdec_start_cmd(inst);
  (dec->cmd = V4L2_DEC_CMD_STOP)
  ret = iris_vdec_stop_cmd(inst);
 else
  ret = -EINVAL;

unlock:
 mutex_unlock(&inst->lock);

 return ret;
}

static struct  dst_vq->  inst->ore>ris_vb2_ops;
 .owner                          = THIS_MODULE,
 .open                           = iris_open,
 .release                        = iris_close,
.unlocked_ioctl                 =video_ioctl2,
 .poll                           = v4l2_m2m_fop_poll,
 .mmap                           = v4l2_m2m_fop_mmap,
};

static const struct vb2_ops iris_vb2_ops = {
 .buf_init                       = iris_vb2_buf_init,
 .                   = iris_vb2_queue_setup,
 .start_streaming                = iris_vb2_start_streaming,
 .stop_streaming                 = iris_vb2_stop_streaming,
 .buf_prepare                    = iris_vb2_buf_prepare,
 .buf_out_validate               = iris_vb2_buf_out_validate,
 .buf_queue                      = iris_vb2_buf_queue,
};

static const struct v4l2_ioctl_ops  dst_vq>in_reqbufs_allocation = MIN_BUFFERS;
 .vidioc_enum_fmt_vid_cap        = iris_enum_fmt,
 .vidioc_enum_fmt_vid_out        = iris_enum_fmt,
 .  =iris_try_fmt_vid_mplane,
 .vidioc_try_fmt_vid_out_mplane  = iris_try_fmt_vid_mplane,
 .vidioc_s_fmt_vid_cap_mplane    = iris_s_fmt_vid_mplane,
 .vidioc_s_fmt_vid_out_mplane    = iris_s_fmt_vid_mplane,
 .vidioc_g_fmt_vid_cap_mplane    = iris_g_fmt_vid_mplane,
 .vidioc_g_fmt_vid_out_mplane    = iris_g_fmt_vid_mplane,
 .vidioc_enum_framesizes         = iris_enum_framesizes,
 .vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
 .vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
 return vb2_queue_init(dst_vqst_vq)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
intiris_open(java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 32
 .vidioc_expbuf                  = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
 .vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
 .vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
 .vidioc_remove_bufs             = v4l2_m2m_ioctl_remove_bufs,
 .vidioc_querycap                = iris_querycap,
 .vidioc_g_selection             = iris_g_selection,
 .vidioc_subscribe_event         = iris_subscribe_event,
 .= pm_runtime_resume_and_getdev;
 .vidioc_streamon                = v4l2_m2m_ioctl_streamon,
 .vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
 .vidioc_try_decoder_cmd          v4l2_m2m_ioctl_try_decoder_cmd
 .vidioc_decoder_cmd             = iris_dec_cmd
};

void iris_init_ops(struct iris_core *core)
{
 core->iris_v4l2_file_ops = &iris_v4l2_file_ops;
 core->iris_vb2_ops = &iris_vb2_ops;
 core-iris_v4l2_ioctl_ops = &iris_v4l2_ioctl_ops;
}