iris_vidc.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
  4 */
  5
  6#include <linux/pm_runtime.h>
  7#include <media/v4l2-event.h>
  8#include <media/v4l2-ioctl.h>
  9#include <media/v4l2-mem2mem.h>
 10#include <media/videobuf2-dma-contig.h>
 11
 12#include "iris_vidc.h"
 13#include "iris_instance.h"
 14#include "iris_vdec.h"
 15#include "iris_venc.h"
 16#include "iris_vb2.h"
 17#include "iris_vpu_buffer.h"
 18#include "iris_platform_common.h"
 19
 20#define IRIS_DRV_NAME "iris_driver"
 21#define IRIS_BUS_NAME "platform:iris_icc"
 22#define STEP_WIDTH 1
 23#define STEP_HEIGHT 1
 24
 25static void iris_v4l2_fh_init(struct iris_inst *inst, struct file *filp)
 26{
 27	if (inst->domain == ENCODER)
 28		v4l2_fh_init(&inst->fh, inst->core->vdev_enc);
 29	else if (inst->domain == DECODER)
 30		v4l2_fh_init(&inst->fh, inst->core->vdev_dec);
 31	inst->fh.ctrl_handler = &inst->ctrl_handler;
 32	v4l2_fh_add(&inst->fh, filp);
 33}
 34
 35static void iris_v4l2_fh_deinit(struct iris_inst *inst, struct file *filp)
 36{
 37	v4l2_fh_del(&inst->fh, filp);
 38	inst->fh.ctrl_handler = NULL;
 39	v4l2_fh_exit(&inst->fh);
 40}
 41
 42static void iris_add_session(struct iris_inst *inst)
 43{
 44	struct iris_core *core = inst->core;
 45	struct iris_inst *iter;
 46	u32 count = 0;
 47
 48	mutex_lock(&core->lock);
 49
 50	list_for_each_entry(iter, &core->instances, list)
 51		count++;
 52
 53	if (count < core->iris_platform_data->max_session_count)
 54		list_add_tail(&inst->list, &core->instances);
 55
 56	mutex_unlock(&core->lock);
 57}
 58
 59static void iris_remove_session(struct iris_inst *inst)
 60{
 61	struct iris_core *core = inst->core;
 62	struct iris_inst *iter, *temp;
 63
 64	mutex_lock(&core->lock);
 65	list_for_each_entry_safe(iter, temp, &core->instances, list) {
 66		if (iter->session_id == inst->session_id) {
 67			list_del_init(&iter->list);
 68			break;
 69		}
 70	}
 71	mutex_unlock(&core->lock);
 72}
 73
 74static inline struct iris_inst *iris_get_inst(struct file *filp)
 75{
 76	return container_of(file_to_v4l2_fh(filp), struct iris_inst, fh);
 77}
 78
 79static void iris_m2m_device_run(void *priv)
 80{
 81}
 82
 83static void iris_m2m_job_abort(void *priv)
 84{
 85	struct iris_inst *inst = priv;
 86	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
 87
 88	v4l2_m2m_job_finish(inst->m2m_dev, m2m_ctx);
 89}
 90
 91static const struct v4l2_m2m_ops iris_m2m_ops = {
 92	.device_run = iris_m2m_device_run,
 93	.job_abort = iris_m2m_job_abort,
 94};
 95
 96static int
 97iris_m2m_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq)
 98{
 99	struct iris_inst *inst = priv;
100	int ret;
101
102	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
103	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
104	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
105	src_vq->ops = inst->core->iris_vb2_ops;
106	src_vq->mem_ops = &vb2_dma_contig_memops;
107	src_vq->drv_priv = inst;
108	src_vq->buf_struct_size = sizeof(struct iris_buffer);
109	src_vq->min_reqbufs_allocation = MIN_BUFFERS;
110	src_vq->dev = inst->core->dev;
111	src_vq->lock = &inst->ctx_q_lock;
112	ret = vb2_queue_init(src_vq);
113	if (ret)
114		return ret;
115
116	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
117	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
118	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
119	dst_vq->ops = inst->core->iris_vb2_ops;
120	dst_vq->mem_ops = &vb2_dma_contig_memops;
121	dst_vq->drv_priv = inst;
122	dst_vq->buf_struct_size = sizeof(struct iris_buffer);
123	dst_vq->min_reqbufs_allocation = MIN_BUFFERS;
124	dst_vq->dev = inst->core->dev;
125	dst_vq->lock = &inst->ctx_q_lock;
126
127	return vb2_queue_init(dst_vq);
128}
129
130int iris_open(struct file *filp)
131{
132	struct iris_core *core = video_drvdata(filp);
133	struct video_device *vdev;
134	struct iris_inst *inst;
135	u32 session_type;
136	int ret;
137
138	vdev = video_devdata(filp);
139	if (strcmp(vdev->name, "qcom-iris-decoder") == 0)
140		session_type = DECODER;
141	else if (strcmp(vdev->name, "qcom-iris-encoder") == 0)
142		session_type = ENCODER;
143	else
144		return -EINVAL;
145
146	ret = pm_runtime_resume_and_get(core->dev);
147	if (ret < 0)
148		return ret;
149
150	ret = iris_core_init(core);
151	if (ret) {
152		dev_err(core->dev, "core init failed\n");
153		pm_runtime_put_sync(core->dev);
154		return ret;
155	}
156
157	pm_runtime_put_sync(core->dev);
158
159	inst = core->iris_platform_data->get_instance();
160	if (!inst)
161		return -ENOMEM;
162
163	inst->core = core;
164	inst->domain = session_type;
165	inst->session_id = hash32_ptr(inst);
166	inst->state = IRIS_INST_DEINIT;
167
168	mutex_init(&inst->lock);
169	mutex_init(&inst->ctx_q_lock);
170
171	INIT_LIST_HEAD(&inst->buffers[BUF_BIN].list);
172	INIT_LIST_HEAD(&inst->buffers[BUF_ARP].list);
173	INIT_LIST_HEAD(&inst->buffers[BUF_COMV].list);
174	INIT_LIST_HEAD(&inst->buffers[BUF_NON_COMV].list);
175	INIT_LIST_HEAD(&inst->buffers[BUF_LINE].list);
176	INIT_LIST_HEAD(&inst->buffers[BUF_DPB].list);
177	INIT_LIST_HEAD(&inst->buffers[BUF_PERSIST].list);
178	INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_1].list);
179	INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_2].list);
180	INIT_LIST_HEAD(&inst->buffers[BUF_VPSS].list);
181	init_completion(&inst->completion);
182	init_completion(&inst->flush_completion);
183
184	iris_v4l2_fh_init(inst, filp);
185
186	inst->m2m_dev = v4l2_m2m_init(&iris_m2m_ops);
187	if (IS_ERR_OR_NULL(inst->m2m_dev)) {
188		ret = -EINVAL;
189		goto fail_v4l2_fh_deinit;
190	}
191
192	inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, iris_m2m_queue_init);
193	if (IS_ERR_OR_NULL(inst->m2m_ctx)) {
194		ret = -EINVAL;
195		goto fail_m2m_release;
196	}
197
198	if (inst->domain == DECODER)
199		ret = iris_vdec_inst_init(inst);
200	else if (inst->domain == ENCODER)
201		ret = iris_venc_inst_init(inst);
202	if (ret)
203		goto fail_m2m_ctx_release;
204
205	iris_add_session(inst);
206
207	inst->fh.m2m_ctx = inst->m2m_ctx;
208
209	return 0;
210
211fail_m2m_ctx_release:
212	v4l2_m2m_ctx_release(inst->m2m_ctx);
213fail_m2m_release:
214	v4l2_m2m_release(inst->m2m_dev);
215fail_v4l2_fh_deinit:
216	iris_v4l2_fh_deinit(inst, filp);
217	mutex_destroy(&inst->ctx_q_lock);
218	mutex_destroy(&inst->lock);
219	kfree(inst);
220
221	return ret;
222}
223
224static void iris_session_close(struct iris_inst *inst)
225{
226	const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;
227	bool wait_for_response = true;
228	int ret;
229
230	if (inst->state == IRIS_INST_DEINIT)
231		return;
232
233	reinit_completion(&inst->completion);
234
235	ret = hfi_ops->session_close(inst);
236	if (ret)
237		wait_for_response = false;
238
239	if (wait_for_response)
240		iris_wait_for_session_response(inst, false);
241}
242
243static void iris_check_num_queued_internal_buffers(struct iris_inst *inst, u32 plane)
244{
245	const struct iris_platform_data *platform_data = inst->core->iris_platform_data;
246	struct iris_buffer *buf, *next;
247	struct iris_buffers *buffers;
248	const u32 *internal_buf_type;
249	u32 internal_buffer_count, i;
250	u32 count = 0;
251
252	if (V4L2_TYPE_IS_OUTPUT(plane)) {
253		internal_buf_type = platform_data->dec_ip_int_buf_tbl;
254		internal_buffer_count = platform_data->dec_ip_int_buf_tbl_size;
255	} else {
256		internal_buf_type = platform_data->dec_op_int_buf_tbl;
257		internal_buffer_count = platform_data->dec_op_int_buf_tbl_size;
258	}
259
260	for (i = 0; i < internal_buffer_count; i++) {
261		buffers = &inst->buffers[internal_buf_type[i]];
262		count = 0;
263		list_for_each_entry_safe(buf, next, &buffers->list, list)
264			count++;
265		if (count)
266			dev_err(inst->core->dev, "%d buffer of type %d not released",
267				count, internal_buf_type[i]);
268	}
269
270	if (inst->domain == DECODER)
271		buffers = &inst->buffers[BUF_PERSIST];
272	else
273		buffers = &inst->buffers[BUF_ARP];
274
275	count = 0;
276	list_for_each_entry_safe(buf, next, &buffers->list, list)
277		count++;
278	if (count)
279		dev_err(inst->core->dev, "%d buffer of type %d not released",
280			count, inst->domain == DECODER ? BUF_PERSIST : BUF_ARP);
281}
282
283int iris_close(struct file *filp)
284{
285	struct iris_inst *inst = iris_get_inst(filp);
286
287	v4l2_ctrl_handler_free(&inst->ctrl_handler);
288	v4l2_m2m_ctx_release(inst->m2m_ctx);
289	v4l2_m2m_release(inst->m2m_dev);
290	mutex_lock(&inst->lock);
291	if (inst->domain == DECODER)
292		iris_vdec_inst_deinit(inst);
293	else if (inst->domain == ENCODER)
294		iris_venc_inst_deinit(inst);
295	iris_session_close(inst);
296	iris_inst_change_state(inst, IRIS_INST_DEINIT);
297	iris_v4l2_fh_deinit(inst, filp);
298	iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
299	iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
300	iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
301	iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
302	iris_remove_session(inst);
303	mutex_unlock(&inst->lock);
304	mutex_destroy(&inst->ctx_q_lock);
305	mutex_destroy(&inst->lock);
306	kfree(inst);
307
308	return 0;
309}
310
311static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f)
312{
313	struct iris_inst *inst = iris_get_inst(filp);
314
315	if (inst->domain == DECODER)
316		return iris_vdec_enum_fmt(inst, f);
317	else if (inst->domain == ENCODER)
318		return iris_venc_enum_fmt(inst, f);
319	else
320		return -EINVAL;
321}
322
323static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f)
324{
325	struct iris_inst *inst = iris_get_inst(filp);
326	int ret = 0;
327
328	mutex_lock(&inst->lock);
329
330	if (inst->domain == DECODER)
331		ret = iris_vdec_try_fmt(inst, f);
332	else if (inst->domain == ENCODER)
333		ret = iris_venc_try_fmt(inst, f);
334
335	mutex_unlock(&inst->lock);
336
337	return ret;
338}
339
340static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f)
341{
342	struct iris_inst *inst = iris_get_inst(filp);
343	int ret = 0;
344
345	mutex_lock(&inst->lock);
346
347	if (inst->domain == DECODER)
348		ret = iris_vdec_s_fmt(inst, f);
349	else if (inst->domain == ENCODER)
350		ret = iris_venc_s_fmt(inst, f);
351
352	mutex_unlock(&inst->lock);
353
354	return ret;
355}
356
357static int iris_g_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f)
358{
359	struct iris_inst *inst = iris_get_inst(filp);
360	int ret = 0;
361
362	mutex_lock(&inst->lock);
363	if (V4L2_TYPE_IS_OUTPUT(f->type))
364		*f = *inst->fmt_src;
365	else if (V4L2_TYPE_IS_CAPTURE(f->type))
366		*f = *inst->fmt_dst;
367	else
368		ret = -EINVAL;
369
370	mutex_unlock(&inst->lock);
371
372	return ret;
373}
374
375static int iris_enum_framesizes(struct file *filp, void *fh,
376				struct v4l2_frmsizeenum *fsize)
377{
378	struct iris_inst *inst = iris_get_inst(filp);
379	struct platform_inst_caps *caps;
380	int ret = 0;
381
382	if (fsize->index)
383		return -EINVAL;
384
385	if (inst->domain == DECODER)
386		ret = iris_vdec_validate_format(inst, fsize->pixel_format);
387	else
388		ret = iris_venc_validate_format(inst, fsize->pixel_format);
389
390	if (ret)
391		return ret;
392
393	caps = inst->core->iris_platform_data->inst_caps;
394
395	fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
396	fsize->stepwise.min_width = caps->min_frame_width;
397	fsize->stepwise.max_width = caps->max_frame_width;
398	fsize->stepwise.step_width = STEP_WIDTH;
399	fsize->stepwise.min_height = caps->min_frame_height;
400	fsize->stepwise.max_height = caps->max_frame_height;
401	fsize->stepwise.step_height = STEP_HEIGHT;
402
403	return ret;
404}
405
406static int iris_enum_frameintervals(struct file *filp, void *fh,
407				    struct v4l2_frmivalenum *fival)
408
409{
410	struct iris_inst *inst = iris_get_inst(filp);
411	struct iris_core *core = inst->core;
412	struct platform_inst_caps *caps;
413	u32 fps, mbpf;
414	int ret = 0;
415
416	if (inst->domain == DECODER)
417		return -ENOTTY;
418
419	if (fival->index)
420		return -EINVAL;
421
422	ret = iris_venc_validate_format(inst, fival->pixel_format);
423	if (ret)
424		return ret;
425
426	if (!fival->width || !fival->height)
427		return -EINVAL;
428
429	caps = inst->core->iris_platform_data->inst_caps;
430	if (fival->width > caps->max_frame_width ||
431	    fival->width < caps->min_frame_width ||
432	    fival->height > caps->max_frame_height ||
433	    fival->height < caps->min_frame_height)
434		return -EINVAL;
435
436	mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width);
437	fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf);
438
439	fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
440	fival->stepwise.min.numerator = 1;
441	fival->stepwise.min.denominator =
442			min_t(u32, fps, MAXIMUM_FPS);
443	fival->stepwise.max.numerator = 1;
444	fival->stepwise.max.denominator = 1;
445	fival->stepwise.step.numerator = 1;
446	fival->stepwise.step.denominator = MAXIMUM_FPS;
447
448	return 0;
449}
450
451static int iris_querycap(struct file *filp, void *fh, struct v4l2_capability *cap)
452{
453	struct iris_inst *inst = iris_get_inst(filp);
454
455	strscpy(cap->driver, IRIS_DRV_NAME, sizeof(cap->driver));
456
457	if (inst->domain == DECODER)
458		strscpy(cap->card, "Iris Decoder", sizeof(cap->card));
459	else
460		strscpy(cap->card, "Iris Encoder", sizeof(cap->card));
461
462	return 0;
463}
464
465static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s)
466{
467	struct iris_inst *inst = iris_get_inst(filp);
468
469	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
470	    inst->domain == DECODER)
471		return -EINVAL;
472
473	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
474	    inst->domain == ENCODER)
475		return -EINVAL;
476
477	if (inst->domain == DECODER) {
478		switch (s->target) {
479		case V4L2_SEL_TGT_CROP_BOUNDS:
480		case V4L2_SEL_TGT_CROP_DEFAULT:
481		case V4L2_SEL_TGT_CROP:
482		case V4L2_SEL_TGT_COMPOSE_BOUNDS:
483		case V4L2_SEL_TGT_COMPOSE_PADDED:
484		case V4L2_SEL_TGT_COMPOSE_DEFAULT:
485		case V4L2_SEL_TGT_COMPOSE:
486			s->r.left = inst->crop.left;
487			s->r.top = inst->crop.top;
488			s->r.width = inst->crop.width;
489			s->r.height = inst->crop.height;
490			break;
491		default:
492			return -EINVAL;
493		}
494	} else if (inst->domain == ENCODER) {
495		switch (s->target) {
496		case V4L2_SEL_TGT_CROP_BOUNDS:
497		case V4L2_SEL_TGT_CROP_DEFAULT:
498			s->r.width = inst->fmt_src->fmt.pix_mp.width;
499			s->r.height = inst->fmt_src->fmt.pix_mp.height;
500			break;
501		case V4L2_SEL_TGT_CROP:
502			s->r.width = inst->crop.width;
503			s->r.height = inst->crop.height;
504			break;
505		default:
506			return -EINVAL;
507		}
508		s->r.left = inst->crop.left;
509		s->r.top = inst->crop.top;
510	}
511
512	return 0;
513}
514
515static int iris_s_selection(struct file *filp, void *fh, struct v4l2_selection *s)
516{
517	struct iris_inst *inst = iris_get_inst(filp);
518
519	if (inst->domain == DECODER)
520		return -EINVAL;
521	else if (inst->domain == ENCODER)
522		return iris_venc_s_selection(inst, s);
523
524	return -EINVAL;
525}
526
527static int iris_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
528{
529	struct iris_inst *inst = container_of(fh, struct iris_inst, fh);
530
531	if (inst->domain == DECODER)
532		return iris_vdec_subscribe_event(inst, sub);
533	else if (inst->domain == ENCODER)
534		return iris_venc_subscribe_event(inst, sub);
535
536	return -EINVAL;
537}
538
539static int iris_s_parm(struct file *filp, void *fh, struct v4l2_streamparm *a)
540{
541	struct iris_inst *inst = iris_get_inst(filp);
542
543	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
544	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
545		return -EINVAL;
546
547	if (inst->domain == ENCODER)
548		return iris_venc_s_param(inst, a);
549	else
550		return -EINVAL;
551}
552
553static int iris_g_parm(struct file *filp, void *fh, struct v4l2_streamparm *a)
554{
555	struct iris_inst *inst = iris_get_inst(filp);
556
557	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
558	    a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
559		return -EINVAL;
560
561	if (inst->domain == ENCODER)
562		return iris_venc_g_param(inst, a);
563	else
564		return -EINVAL;
565}
566
567static int iris_dec_cmd(struct file *filp, void *fh,
568			struct v4l2_decoder_cmd *dec)
569{
570	struct iris_inst *inst = iris_get_inst(filp);
571	int ret = 0;
572
573	mutex_lock(&inst->lock);
574
575	if (dec->cmd != V4L2_DEC_CMD_STOP && dec->cmd != V4L2_DEC_CMD_START) {
576		ret = -EINVAL;
577		goto unlock;
578	}
579
580	if (inst->state == IRIS_INST_DEINIT)
581		goto unlock;
582
583	if (!iris_allow_cmd(inst, dec->cmd)) {
584		ret = -EBUSY;
585		goto unlock;
586	}
587
588	if (dec->cmd == V4L2_DEC_CMD_START)
589		ret = iris_vdec_start_cmd(inst);
590	else if (dec->cmd == V4L2_DEC_CMD_STOP)
591		ret = iris_vdec_stop_cmd(inst);
592	else
593		ret = -EINVAL;
594
595unlock:
596	mutex_unlock(&inst->lock);
597
598	return ret;
599}
600
601static int iris_enc_cmd(struct file *filp, void *fh,
602			struct v4l2_encoder_cmd *enc)
603{
604	struct iris_inst *inst = iris_get_inst(filp);
605	int ret = 0;
606
607	mutex_lock(&inst->lock);
608
609	if (enc->cmd != V4L2_ENC_CMD_STOP && enc->cmd != V4L2_ENC_CMD_START) {
610		ret = -EINVAL;
611		goto unlock;
612	}
613
614	if (inst->state == IRIS_INST_DEINIT)
615		goto unlock;
616
617	if (!iris_allow_cmd(inst, enc->cmd)) {
618		ret = -EBUSY;
619		goto unlock;
620	}
621
622	if (enc->cmd == V4L2_ENC_CMD_START)
623		ret = iris_venc_start_cmd(inst);
624	else if (enc->cmd == V4L2_ENC_CMD_STOP)
625		ret = iris_venc_stop_cmd(inst);
626	else
627		ret = -EINVAL;
628
629unlock:
630	mutex_unlock(&inst->lock);
631
632	return ret;
633}
634
635static const struct v4l2_file_operations iris_v4l2_file_ops = {
636	.owner                          = THIS_MODULE,
637	.open                           = iris_open,
638	.release                        = iris_close,
639	.unlocked_ioctl                 = video_ioctl2,
640	.poll                           = v4l2_m2m_fop_poll,
641	.mmap                           = v4l2_m2m_fop_mmap,
642};
643
644static const struct vb2_ops iris_vb2_ops = {
645	.buf_init                       = iris_vb2_buf_init,
646	.queue_setup                    = iris_vb2_queue_setup,
647	.start_streaming                = iris_vb2_start_streaming,
648	.stop_streaming                 = iris_vb2_stop_streaming,
649	.buf_prepare                    = iris_vb2_buf_prepare,
650	.buf_out_validate               = iris_vb2_buf_out_validate,
651	.buf_queue                      = iris_vb2_buf_queue,
652};
653
654static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_dec = {
655	.vidioc_enum_fmt_vid_cap        = iris_enum_fmt,
656	.vidioc_enum_fmt_vid_out        = iris_enum_fmt,
657	.vidioc_try_fmt_vid_cap_mplane  = iris_try_fmt_vid_mplane,
658	.vidioc_try_fmt_vid_out_mplane  = iris_try_fmt_vid_mplane,
659	.vidioc_s_fmt_vid_cap_mplane    = iris_s_fmt_vid_mplane,
660	.vidioc_s_fmt_vid_out_mplane    = iris_s_fmt_vid_mplane,
661	.vidioc_g_fmt_vid_cap_mplane    = iris_g_fmt_vid_mplane,
662	.vidioc_g_fmt_vid_out_mplane    = iris_g_fmt_vid_mplane,
663	.vidioc_enum_framesizes         = iris_enum_framesizes,
664	.vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
665	.vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
666	.vidioc_create_bufs             = v4l2_m2m_ioctl_create_bufs,
667	.vidioc_prepare_buf             = v4l2_m2m_ioctl_prepare_buf,
668	.vidioc_expbuf                  = v4l2_m2m_ioctl_expbuf,
669	.vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
670	.vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
671	.vidioc_remove_bufs             = v4l2_m2m_ioctl_remove_bufs,
672	.vidioc_querycap                = iris_querycap,
673	.vidioc_g_selection             = iris_g_selection,
674	.vidioc_subscribe_event         = iris_subscribe_event,
675	.vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
676	.vidioc_streamon                = v4l2_m2m_ioctl_streamon,
677	.vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
678	.vidioc_try_decoder_cmd         = v4l2_m2m_ioctl_try_decoder_cmd,
679	.vidioc_decoder_cmd             = iris_dec_cmd,
680};
681
682static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = {
683	.vidioc_enum_fmt_vid_cap        = iris_enum_fmt,
684	.vidioc_enum_fmt_vid_out        = iris_enum_fmt,
685	.vidioc_try_fmt_vid_cap_mplane  = iris_try_fmt_vid_mplane,
686	.vidioc_try_fmt_vid_out_mplane  = iris_try_fmt_vid_mplane,
687	.vidioc_s_fmt_vid_cap_mplane    = iris_s_fmt_vid_mplane,
688	.vidioc_s_fmt_vid_out_mplane    = iris_s_fmt_vid_mplane,
689	.vidioc_g_fmt_vid_cap_mplane    = iris_g_fmt_vid_mplane,
690	.vidioc_g_fmt_vid_out_mplane    = iris_g_fmt_vid_mplane,
691	.vidioc_enum_framesizes         = iris_enum_framesizes,
692	.vidioc_enum_frameintervals     = iris_enum_frameintervals,
693	.vidioc_querycap                = iris_querycap,
694	.vidioc_subscribe_event         = iris_subscribe_event,
695	.vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
696	.vidioc_g_selection             = iris_g_selection,
697	.vidioc_s_selection             = iris_s_selection,
698	.vidioc_s_parm                  = iris_s_parm,
699	.vidioc_g_parm                  = iris_g_parm,
700	.vidioc_streamon                = v4l2_m2m_ioctl_streamon,
701	.vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
702	.vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
703	.vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
704	.vidioc_create_bufs             = v4l2_m2m_ioctl_create_bufs,
705	.vidioc_prepare_buf             = v4l2_m2m_ioctl_prepare_buf,
706	.vidioc_expbuf                  = v4l2_m2m_ioctl_expbuf,
707	.vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
708	.vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
709	.vidioc_remove_bufs             = v4l2_m2m_ioctl_remove_bufs,
710	.vidioc_try_encoder_cmd         = v4l2_m2m_ioctl_try_encoder_cmd,
711	.vidioc_encoder_cmd             = iris_enc_cmd,
712};
713
714void iris_init_ops(struct iris_core *core)
715{
716	core->iris_v4l2_file_ops = &iris_v4l2_file_ops;
717	core->iris_vb2_ops = &iris_vb2_ops;
718	core->iris_v4l2_ioctl_ops_dec = &iris_v4l2_ioctl_ops_dec;
719	core->iris_v4l2_ioctl_ops_enc = &iris_v4l2_ioctl_ops_enc;
720}