1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2022 MediaTek Inc.
4  * Author: Ping-Hsun Wu <ping-hsun.wu@mediatek.com>
5  */
6 
7 #include <linux/platform_device.h>
8 #include <media/v4l2-ioctl.h>
9 #include <media/v4l2-event.h>
10 #include <media/videobuf2-dma-contig.h>
11 #include "mtk-mdp3-m2m.h"
12 
13 static inline struct mdp_m2m_ctx *fh_to_ctx(struct v4l2_fh *fh)
14 {
15 	return container_of(fh, struct mdp_m2m_ctx, fh);
16 }
17 
18 static inline struct mdp_m2m_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl)
19 {
20 	return container_of(ctrl->handler, struct mdp_m2m_ctx, ctrl_handler);
21 }
22 
23 static inline struct mdp_frame *ctx_get_frame(struct mdp_m2m_ctx *ctx,
24 					      enum v4l2_buf_type type)
25 {
26 	if (V4L2_TYPE_IS_OUTPUT(type))
27 		return &ctx->curr_param.output;
28 	else
29 		return &ctx->curr_param.captures[0];
30 }
31 
32 static inline void mdp_m2m_ctx_set_state(struct mdp_m2m_ctx *ctx, u32 state)
33 {
34 	atomic_or(state, &ctx->curr_param.state);
35 }
36 
37 static inline bool mdp_m2m_ctx_is_state_set(struct mdp_m2m_ctx *ctx, u32 mask)
38 {
39 	return ((atomic_read(&ctx->curr_param.state) & mask) == mask);
40 }
41 
42 static void mdp_m2m_process_done(void *priv, int vb_state)
43 {
44 	struct mdp_m2m_ctx *ctx = priv;
45 	struct vb2_v4l2_buffer *src_vbuf, *dst_vbuf;
46 
47 	src_vbuf = (struct vb2_v4l2_buffer *)
48 			v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
49 	dst_vbuf = (struct vb2_v4l2_buffer *)
50 			v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
51 	ctx->curr_param.frame_no = ctx->frame_count[MDP_M2M_SRC];
52 	src_vbuf->sequence = ctx->frame_count[MDP_M2M_SRC]++;
53 	dst_vbuf->sequence = ctx->frame_count[MDP_M2M_DST]++;
54 	v4l2_m2m_buf_copy_metadata(src_vbuf, dst_vbuf, true);
55 
56 	v4l2_m2m_buf_done(src_vbuf, vb_state);
57 	v4l2_m2m_buf_done(dst_vbuf, vb_state);
58 	v4l2_m2m_job_finish(ctx->mdp_dev->m2m_dev, ctx->m2m_ctx);
59 }
60 
61 static void mdp_m2m_device_run(void *priv)
62 {
63 	struct mdp_m2m_ctx *ctx = priv;
64 	struct mdp_frame *frame;
65 	struct vb2_v4l2_buffer *src_vb, *dst_vb;
66 	struct img_ipi_frameparam param = {};
67 	struct mdp_cmdq_param task = {};
68 	enum vb2_buffer_state vb_state = VB2_BUF_STATE_ERROR;
69 	int ret;
70 
71 	if (mdp_m2m_ctx_is_state_set(ctx, MDP_M2M_CTX_ERROR)) {
72 		dev_err(&ctx->mdp_dev->pdev->dev,
73 			"mdp_m2m_ctx is in error state\n");
74 		goto worker_end;
75 	}
76 
77 	param.frame_no = ctx->curr_param.frame_no;
78 	param.type = ctx->curr_param.type;
79 	param.num_inputs = 1;
80 	param.num_outputs = 1;
81 
82 	frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
83 	src_vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
84 	mdp_set_src_config(&param.inputs[0], frame, &src_vb->vb2_buf);
85 
86 	frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
87 	dst_vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
88 	mdp_set_dst_config(&param.outputs[0], frame, &dst_vb->vb2_buf);
89 
90 	ret = mdp_vpu_process(&ctx->mdp_dev->vpu, &param);
91 	if (ret) {
92 		dev_err(&ctx->mdp_dev->pdev->dev,
93 			"VPU MDP process failed: %d\n", ret);
94 		goto worker_end;
95 	}
96 
97 	task.config = ctx->mdp_dev->vpu.config;
98 	task.param = &param;
99 	task.composes[0] = &frame->compose;
100 	task.cmdq_cb = NULL;
101 	task.cb_data = NULL;
102 	task.mdp_ctx = ctx;
103 
104 	ret = mdp_cmdq_send(ctx->mdp_dev, &task);
105 	if (ret) {
106 		dev_err(&ctx->mdp_dev->pdev->dev,
107 			"CMDQ sendtask failed: %d\n", ret);
108 		goto worker_end;
109 	}
110 
111 	return;
112 
113 worker_end:
114 	mdp_m2m_process_done(ctx, vb_state);
115 }
116 
117 static int mdp_m2m_start_streaming(struct vb2_queue *q, unsigned int count)
118 {
119 	struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
120 	struct mdp_frame *capture;
121 	struct vb2_queue *vq;
122 	int ret;
123 	bool out_streaming, cap_streaming;
124 
125 	if (V4L2_TYPE_IS_OUTPUT(q->type))
126 		ctx->frame_count[MDP_M2M_SRC] = 0;
127 
128 	if (V4L2_TYPE_IS_CAPTURE(q->type))
129 		ctx->frame_count[MDP_M2M_DST] = 0;
130 
131 	capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
132 	vq = v4l2_m2m_get_src_vq(ctx->m2m_ctx);
133 	out_streaming = vb2_is_streaming(vq);
134 	vq = v4l2_m2m_get_dst_vq(ctx->m2m_ctx);
135 	cap_streaming = vb2_is_streaming(vq);
136 
137 	/* Check to see if scaling ratio is within supported range */
138 	if ((V4L2_TYPE_IS_OUTPUT(q->type) && cap_streaming) ||
139 	    (V4L2_TYPE_IS_CAPTURE(q->type) && out_streaming)) {
140 		ret = mdp_check_scaling_ratio(&capture->crop.c,
141 					      &capture->compose,
142 					      capture->rotation,
143 					      ctx->curr_param.limit);
144 		if (ret) {
145 			dev_err(&ctx->mdp_dev->pdev->dev,
146 				"Out of scaling range\n");
147 			return ret;
148 		}
149 	}
150 
151 	if (!mdp_m2m_ctx_is_state_set(ctx, MDP_VPU_INIT)) {
152 		ret = mdp_vpu_get_locked(ctx->mdp_dev);
153 		if (ret) {
154 			dev_err(&ctx->mdp_dev->pdev->dev,
155 				"VPU init failed %d\n", ret);
156 			return -EINVAL;
157 		}
158 		mdp_m2m_ctx_set_state(ctx, MDP_VPU_INIT);
159 	}
160 
161 	return 0;
162 }
163 
164 static struct vb2_v4l2_buffer *mdp_m2m_buf_remove(struct mdp_m2m_ctx *ctx,
165 						  unsigned int type)
166 {
167 	if (V4L2_TYPE_IS_OUTPUT(type))
168 		return (struct vb2_v4l2_buffer *)
169 			v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
170 	else
171 		return (struct vb2_v4l2_buffer *)
172 			v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
173 }
174 
175 static void mdp_m2m_stop_streaming(struct vb2_queue *q)
176 {
177 	struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
178 	struct vb2_v4l2_buffer *vb;
179 
180 	vb = mdp_m2m_buf_remove(ctx, q->type);
181 	while (vb) {
182 		v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR);
183 		vb = mdp_m2m_buf_remove(ctx, q->type);
184 	}
185 }
186 
187 static int mdp_m2m_queue_setup(struct vb2_queue *q,
188 			       unsigned int *num_buffers,
189 			       unsigned int *num_planes, unsigned int sizes[],
190 			       struct device *alloc_devs[])
191 {
192 	struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
193 	struct v4l2_pix_format_mplane *pix_mp;
194 	u32 i;
195 
196 	pix_mp = &ctx_get_frame(ctx, q->type)->format.fmt.pix_mp;
197 
198 	/* from VIDIOC_CREATE_BUFS */
199 	if (*num_planes) {
200 		if (*num_planes != pix_mp->num_planes)
201 			return -EINVAL;
202 		for (i = 0; i < pix_mp->num_planes; ++i)
203 			if (sizes[i] < pix_mp->plane_fmt[i].sizeimage)
204 				return -EINVAL;
205 	} else {/* from VIDIOC_REQBUFS */
206 		*num_planes = pix_mp->num_planes;
207 		for (i = 0; i < pix_mp->num_planes; ++i)
208 			sizes[i] = pix_mp->plane_fmt[i].sizeimage;
209 	}
210 
211 	return 0;
212 }
213 
214 static int mdp_m2m_buf_prepare(struct vb2_buffer *vb)
215 {
216 	struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
217 	struct v4l2_pix_format_mplane *pix_mp;
218 	struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
219 	u32 i;
220 
221 	v4l2_buf->field = V4L2_FIELD_NONE;
222 
223 	if (V4L2_TYPE_IS_CAPTURE(vb->type)) {
224 		pix_mp = &ctx_get_frame(ctx, vb->type)->format.fmt.pix_mp;
225 		for (i = 0; i < pix_mp->num_planes; ++i) {
226 			vb2_set_plane_payload(vb, i,
227 					      pix_mp->plane_fmt[i].sizeimage);
228 		}
229 	}
230 	return 0;
231 }
232 
233 static int mdp_m2m_buf_out_validate(struct vb2_buffer *vb)
234 {
235 	struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
236 
237 	v4l2_buf->field = V4L2_FIELD_NONE;
238 
239 	return 0;
240 }
241 
242 static void mdp_m2m_buf_queue(struct vb2_buffer *vb)
243 {
244 	struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
245 	struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
246 
247 	v4l2_buf->field = V4L2_FIELD_NONE;
248 
249 	v4l2_m2m_buf_queue(ctx->m2m_ctx, to_vb2_v4l2_buffer(vb));
250 }
251 
252 static const struct vb2_ops mdp_m2m_qops = {
253 	.queue_setup	= mdp_m2m_queue_setup,
254 	.wait_prepare	= vb2_ops_wait_prepare,
255 	.wait_finish	= vb2_ops_wait_finish,
256 	.buf_prepare	= mdp_m2m_buf_prepare,
257 	.start_streaming = mdp_m2m_start_streaming,
258 	.stop_streaming	= mdp_m2m_stop_streaming,
259 	.buf_queue	= mdp_m2m_buf_queue,
260 	.buf_out_validate = mdp_m2m_buf_out_validate,
261 };
262 
263 static int mdp_m2m_querycap(struct file *file, void *fh,
264 			    struct v4l2_capability *cap)
265 {
266 	strscpy(cap->driver, MDP_MODULE_NAME, sizeof(cap->driver));
267 	strscpy(cap->card, MDP_DEVICE_NAME, sizeof(cap->card));
268 
269 	return 0;
270 }
271 
272 static int mdp_m2m_enum_fmt_mplane(struct file *file, void *fh,
273 				   struct v4l2_fmtdesc *f)
274 {
275 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
276 
277 	return mdp_enum_fmt_mplane(ctx->mdp_dev, f);
278 }
279 
280 static int mdp_m2m_g_fmt_mplane(struct file *file, void *fh,
281 				struct v4l2_format *f)
282 {
283 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
284 	struct mdp_frame *frame;
285 	struct v4l2_pix_format_mplane *pix_mp;
286 
287 	frame = ctx_get_frame(ctx, f->type);
288 	*f = frame->format;
289 	pix_mp = &f->fmt.pix_mp;
290 	pix_mp->colorspace = ctx->curr_param.colorspace;
291 	pix_mp->xfer_func = ctx->curr_param.xfer_func;
292 	pix_mp->ycbcr_enc = ctx->curr_param.ycbcr_enc;
293 	pix_mp->quantization = ctx->curr_param.quant;
294 
295 	return 0;
296 }
297 
298 static int mdp_m2m_s_fmt_mplane(struct file *file, void *fh,
299 				struct v4l2_format *f)
300 {
301 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
302 	struct mdp_frame *frame = ctx_get_frame(ctx, f->type);
303 	struct mdp_frame *capture;
304 	const struct mdp_format *fmt;
305 	struct vb2_queue *vq;
306 
307 	fmt = mdp_try_fmt_mplane(ctx->mdp_dev, f, &ctx->curr_param, ctx->id);
308 	if (!fmt)
309 		return -EINVAL;
310 
311 	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
312 	if (vb2_is_busy(vq))
313 		return -EBUSY;
314 
315 	frame->format = *f;
316 	frame->mdp_fmt = fmt;
317 	frame->ycbcr_prof = mdp_map_ycbcr_prof_mplane(f, fmt->mdp_color);
318 	frame->usage = V4L2_TYPE_IS_OUTPUT(f->type) ?
319 		MDP_BUFFER_USAGE_HW_READ : MDP_BUFFER_USAGE_MDP;
320 
321 	capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
322 	if (V4L2_TYPE_IS_OUTPUT(f->type)) {
323 		capture->crop.c.left = 0;
324 		capture->crop.c.top = 0;
325 		capture->crop.c.width = f->fmt.pix_mp.width;
326 		capture->crop.c.height = f->fmt.pix_mp.height;
327 		ctx->curr_param.colorspace = f->fmt.pix_mp.colorspace;
328 		ctx->curr_param.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc;
329 		ctx->curr_param.quant = f->fmt.pix_mp.quantization;
330 		ctx->curr_param.xfer_func = f->fmt.pix_mp.xfer_func;
331 	} else {
332 		capture->compose.left = 0;
333 		capture->compose.top = 0;
334 		capture->compose.width = f->fmt.pix_mp.width;
335 		capture->compose.height = f->fmt.pix_mp.height;
336 	}
337 
338 	return 0;
339 }
340 
341 static int mdp_m2m_try_fmt_mplane(struct file *file, void *fh,
342 				  struct v4l2_format *f)
343 {
344 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
345 
346 	if (!mdp_try_fmt_mplane(ctx->mdp_dev, f, &ctx->curr_param, ctx->id))
347 		return -EINVAL;
348 
349 	return 0;
350 }
351 
352 static int mdp_m2m_g_selection(struct file *file, void *fh,
353 			       struct v4l2_selection *s)
354 {
355 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
356 	struct mdp_frame *frame;
357 	bool valid = false;
358 
359 	if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
360 		valid = mdp_target_is_crop(s->target);
361 	else if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
362 		valid = mdp_target_is_compose(s->target);
363 
364 	if (!valid)
365 		return -EINVAL;
366 
367 	switch (s->target) {
368 	case V4L2_SEL_TGT_CROP:
369 		if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
370 			return -EINVAL;
371 		frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
372 		s->r = frame->crop.c;
373 		return 0;
374 	case V4L2_SEL_TGT_COMPOSE:
375 		if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
376 			return -EINVAL;
377 		frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
378 		s->r = frame->compose;
379 		return 0;
380 	case V4L2_SEL_TGT_CROP_DEFAULT:
381 	case V4L2_SEL_TGT_CROP_BOUNDS:
382 		if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
383 			return -EINVAL;
384 		frame = ctx_get_frame(ctx, s->type);
385 		s->r.left = 0;
386 		s->r.top = 0;
387 		s->r.width = frame->format.fmt.pix_mp.width;
388 		s->r.height = frame->format.fmt.pix_mp.height;
389 		return 0;
390 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
391 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
392 		if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
393 			return -EINVAL;
394 		frame = ctx_get_frame(ctx, s->type);
395 		s->r.left = 0;
396 		s->r.top = 0;
397 		s->r.width = frame->format.fmt.pix_mp.width;
398 		s->r.height = frame->format.fmt.pix_mp.height;
399 		return 0;
400 	}
401 	return -EINVAL;
402 }
403 
404 static int mdp_m2m_s_selection(struct file *file, void *fh,
405 			       struct v4l2_selection *s)
406 {
407 	struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
408 	struct mdp_frame *frame = ctx_get_frame(ctx, s->type);
409 	struct mdp_frame *capture;
410 	struct v4l2_rect r;
411 	struct device *dev = &ctx->mdp_dev->pdev->dev;
412 	bool valid = false;
413 	int ret;
414 
415 	if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
416 		valid = (s->target == V4L2_SEL_TGT_CROP);
417 	else if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
418 		valid = (s->target == V4L2_SEL_TGT_COMPOSE);
419 
420 	if (!valid) {
421 		dev_dbg(dev, "[%s:%d] invalid type:%u target:%u", __func__,
422 			ctx->id, s->type, s->target);
423 		return -EINVAL;
424 	}
425 
426 	ret = mdp_try_crop(ctx, &r, s, frame);
427 	if (ret)
428 		return ret;
429 	capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
430 
431 	if (mdp_target_is_crop(s->target))
432 		capture->crop.c = r;
433 	else
434 		capture->compose = r;
435 
436 	s->r = r;
437 
438 	return 0;
439 }
440 
441 static const struct v4l2_ioctl_ops mdp_m2m_ioctl_ops = {
442 	.vidioc_querycap		= mdp_m2m_querycap,
443 	.vidioc_enum_fmt_vid_cap	= mdp_m2m_enum_fmt_mplane,
444 	.vidioc_enum_fmt_vid_out	= mdp_m2m_enum_fmt_mplane,
445 	.vidioc_g_fmt_vid_cap_mplane	= mdp_m2m_g_fmt_mplane,
446 	.vidioc_g_fmt_vid_out_mplane	= mdp_m2m_g_fmt_mplane,
447 	.vidioc_s_fmt_vid_cap_mplane	= mdp_m2m_s_fmt_mplane,
448 	.vidioc_s_fmt_vid_out_mplane	= mdp_m2m_s_fmt_mplane,
449 	.vidioc_try_fmt_vid_cap_mplane	= mdp_m2m_try_fmt_mplane,
450 	.vidioc_try_fmt_vid_out_mplane	= mdp_m2m_try_fmt_mplane,
451 	.vidioc_reqbufs			= v4l2_m2m_ioctl_reqbufs,
452 	.vidioc_querybuf		= v4l2_m2m_ioctl_querybuf,
453 	.vidioc_qbuf			= v4l2_m2m_ioctl_qbuf,
454 	.vidioc_expbuf			= v4l2_m2m_ioctl_expbuf,
455 	.vidioc_dqbuf			= v4l2_m2m_ioctl_dqbuf,
456 	.vidioc_create_bufs		= v4l2_m2m_ioctl_create_bufs,
457 	.vidioc_streamon		= v4l2_m2m_ioctl_streamon,
458 	.vidioc_streamoff		= v4l2_m2m_ioctl_streamoff,
459 	.vidioc_g_selection		= mdp_m2m_g_selection,
460 	.vidioc_s_selection		= mdp_m2m_s_selection,
461 	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
462 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
463 };
464 
465 static int mdp_m2m_queue_init(void *priv,
466 			      struct vb2_queue *src_vq,
467 			      struct vb2_queue *dst_vq)
468 {
469 	struct mdp_m2m_ctx *ctx = priv;
470 	int ret;
471 
472 	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
473 	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
474 	src_vq->ops = &mdp_m2m_qops;
475 	src_vq->mem_ops = &vb2_dma_contig_memops;
476 	src_vq->drv_priv = ctx;
477 	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
478 	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
479 	src_vq->dev = &ctx->mdp_dev->pdev->dev;
480 	src_vq->lock = &ctx->ctx_lock;
481 
482 	ret = vb2_queue_init(src_vq);
483 	if (ret)
484 		return ret;
485 
486 	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
487 	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
488 	dst_vq->ops = &mdp_m2m_qops;
489 	dst_vq->mem_ops = &vb2_dma_contig_memops;
490 	dst_vq->drv_priv = ctx;
491 	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
492 	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
493 	dst_vq->dev = &ctx->mdp_dev->pdev->dev;
494 	dst_vq->lock = &ctx->ctx_lock;
495 
496 	return vb2_queue_init(dst_vq);
497 }
498 
499 static int mdp_m2m_s_ctrl(struct v4l2_ctrl *ctrl)
500 {
501 	struct mdp_m2m_ctx *ctx = ctrl_to_ctx(ctrl);
502 	struct mdp_frame *capture;
503 
504 	capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
505 	switch (ctrl->id) {
506 	case V4L2_CID_HFLIP:
507 		capture->hflip = ctrl->val;
508 		break;
509 	case V4L2_CID_VFLIP:
510 		capture->vflip = ctrl->val;
511 		break;
512 	case V4L2_CID_ROTATE:
513 		capture->rotation = ctrl->val;
514 		break;
515 	}
516 
517 	return 0;
518 }
519 
520 static const struct v4l2_ctrl_ops mdp_m2m_ctrl_ops = {
521 	.s_ctrl	= mdp_m2m_s_ctrl,
522 };
523 
524 static int mdp_m2m_ctrls_create(struct mdp_m2m_ctx *ctx)
525 {
526 	v4l2_ctrl_handler_init(&ctx->ctrl_handler, MDP_MAX_CTRLS);
527 	ctx->ctrls.hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,
528 					     &mdp_m2m_ctrl_ops, V4L2_CID_HFLIP,
529 					     0, 1, 1, 0);
530 	ctx->ctrls.vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,
531 					     &mdp_m2m_ctrl_ops, V4L2_CID_VFLIP,
532 					     0, 1, 1, 0);
533 	ctx->ctrls.rotate = v4l2_ctrl_new_std(&ctx->ctrl_handler,
534 					      &mdp_m2m_ctrl_ops,
535 					      V4L2_CID_ROTATE, 0, 270, 90, 0);
536 
537 	if (ctx->ctrl_handler.error) {
538 		int err = ctx->ctrl_handler.error;
539 
540 		v4l2_ctrl_handler_free(&ctx->ctrl_handler);
541 		dev_err(&ctx->mdp_dev->pdev->dev,
542 			"Failed to register controls\n");
543 		return err;
544 	}
545 	return 0;
546 }
547 
548 static int mdp_m2m_open(struct file *file)
549 {
550 	struct video_device *vdev = video_devdata(file);
551 	struct mdp_dev *mdp = video_get_drvdata(vdev);
552 	struct mdp_m2m_ctx *ctx;
553 	struct device *dev = &mdp->pdev->dev;
554 	int ret;
555 	struct v4l2_format default_format = {};
556 	const struct mdp_limit *limit = mdp->mdp_data->def_limit;
557 
558 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
559 	if (!ctx)
560 		return -ENOMEM;
561 
562 	if (mutex_lock_interruptible(&mdp->m2m_lock)) {
563 		ret = -ERESTARTSYS;
564 		goto err_free_ctx;
565 	}
566 
567 	ret = ida_alloc(&mdp->mdp_ida, GFP_KERNEL);
568 	if (ret < 0)
569 		goto err_unlock_mutex;
570 	ctx->id = ret;
571 
572 	ctx->mdp_dev = mdp;
573 
574 	v4l2_fh_init(&ctx->fh, vdev);
575 	file->private_data = &ctx->fh;
576 	ret = mdp_m2m_ctrls_create(ctx);
577 	if (ret)
578 		goto err_exit_fh;
579 
580 	/* Use separate control handler per file handle */
581 	ctx->fh.ctrl_handler = &ctx->ctrl_handler;
582 	v4l2_fh_add(&ctx->fh);
583 
584 	mutex_init(&ctx->ctx_lock);
585 	ctx->m2m_ctx = v4l2_m2m_ctx_init(mdp->m2m_dev, ctx, mdp_m2m_queue_init);
586 	if (IS_ERR(ctx->m2m_ctx)) {
587 		dev_err(dev, "Failed to initialize m2m context\n");
588 		ret = PTR_ERR(ctx->m2m_ctx);
589 		goto err_release_handler;
590 	}
591 	ctx->fh.m2m_ctx = ctx->m2m_ctx;
592 
593 	ctx->curr_param.ctx = ctx;
594 	ret = mdp_frameparam_init(mdp, &ctx->curr_param);
595 	if (ret) {
596 		dev_err(dev, "Failed to initialize mdp parameter\n");
597 		goto err_release_m2m_ctx;
598 	}
599 
600 	mutex_unlock(&mdp->m2m_lock);
601 
602 	/* Default format */
603 	default_format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
604 	default_format.fmt.pix_mp.width = limit->out_limit.wmin;
605 	default_format.fmt.pix_mp.height = limit->out_limit.hmin;
606 	default_format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_YUV420M;
607 	mdp_m2m_s_fmt_mplane(file, &ctx->fh, &default_format);
608 	default_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
609 	mdp_m2m_s_fmt_mplane(file, &ctx->fh, &default_format);
610 
611 	dev_dbg(dev, "%s:[%d]", __func__, ctx->id);
612 
613 	return 0;
614 
615 err_release_m2m_ctx:
616 	v4l2_m2m_ctx_release(ctx->m2m_ctx);
617 err_release_handler:
618 	v4l2_ctrl_handler_free(&ctx->ctrl_handler);
619 	v4l2_fh_del(&ctx->fh);
620 err_exit_fh:
621 	v4l2_fh_exit(&ctx->fh);
622 	ida_free(&mdp->mdp_ida, ctx->id);
623 err_unlock_mutex:
624 	mutex_unlock(&mdp->m2m_lock);
625 err_free_ctx:
626 	kfree(ctx);
627 
628 	return ret;
629 }
630 
631 static int mdp_m2m_release(struct file *file)
632 {
633 	struct mdp_m2m_ctx *ctx = fh_to_ctx(file->private_data);
634 	struct mdp_dev *mdp = video_drvdata(file);
635 	struct device *dev = &mdp->pdev->dev;
636 
637 	mutex_lock(&mdp->m2m_lock);
638 	v4l2_m2m_ctx_release(ctx->m2m_ctx);
639 	if (mdp_m2m_ctx_is_state_set(ctx, MDP_VPU_INIT))
640 		mdp_vpu_put_locked(mdp);
641 
642 	v4l2_ctrl_handler_free(&ctx->ctrl_handler);
643 	v4l2_fh_del(&ctx->fh);
644 	v4l2_fh_exit(&ctx->fh);
645 	ida_free(&mdp->mdp_ida, ctx->id);
646 	mutex_unlock(&mdp->m2m_lock);
647 
648 	dev_dbg(dev, "%s:[%d]", __func__, ctx->id);
649 	kfree(ctx);
650 
651 	return 0;
652 }
653 
654 static const struct v4l2_file_operations mdp_m2m_fops = {
655 	.owner		= THIS_MODULE,
656 	.poll		= v4l2_m2m_fop_poll,
657 	.unlocked_ioctl	= video_ioctl2,
658 	.mmap		= v4l2_m2m_fop_mmap,
659 	.open		= mdp_m2m_open,
660 	.release	= mdp_m2m_release,
661 };
662 
663 static const struct v4l2_m2m_ops mdp_m2m_ops = {
664 	.device_run	= mdp_m2m_device_run,
665 };
666 
667 int mdp_m2m_device_register(struct mdp_dev *mdp)
668 {
669 	struct device *dev = &mdp->pdev->dev;
670 	int ret = 0;
671 
672 	mdp->m2m_vdev = video_device_alloc();
673 	if (!mdp->m2m_vdev) {
674 		dev_err(dev, "Failed to allocate video device\n");
675 		ret = -ENOMEM;
676 		goto err_video_alloc;
677 	}
678 	mdp->m2m_vdev->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE |
679 		V4L2_CAP_STREAMING;
680 	mdp->m2m_vdev->fops = &mdp_m2m_fops;
681 	mdp->m2m_vdev->ioctl_ops = &mdp_m2m_ioctl_ops;
682 	mdp->m2m_vdev->release = mdp_video_device_release;
683 	mdp->m2m_vdev->lock = &mdp->m2m_lock;
684 	mdp->m2m_vdev->vfl_dir = VFL_DIR_M2M;
685 	mdp->m2m_vdev->v4l2_dev = &mdp->v4l2_dev;
686 	snprintf(mdp->m2m_vdev->name, sizeof(mdp->m2m_vdev->name), "%s:m2m",
687 		 MDP_MODULE_NAME);
688 	video_set_drvdata(mdp->m2m_vdev, mdp);
689 
690 	mdp->m2m_dev = v4l2_m2m_init(&mdp_m2m_ops);
691 	if (IS_ERR(mdp->m2m_dev)) {
692 		dev_err(dev, "Failed to initialize v4l2-m2m device\n");
693 		ret = PTR_ERR(mdp->m2m_dev);
694 		goto err_m2m_init;
695 	}
696 
697 	ret = video_register_device(mdp->m2m_vdev, VFL_TYPE_VIDEO, -1);
698 	if (ret) {
699 		dev_err(dev, "Failed to register video device\n");
700 		goto err_video_register;
701 	}
702 
703 	v4l2_info(&mdp->v4l2_dev, "Driver registered as /dev/video%d",
704 		  mdp->m2m_vdev->num);
705 	return 0;
706 
707 err_video_register:
708 	v4l2_m2m_release(mdp->m2m_dev);
709 err_m2m_init:
710 	video_device_release(mdp->m2m_vdev);
711 err_video_alloc:
712 
713 	return ret;
714 }
715 
716 void mdp_m2m_device_unregister(struct mdp_dev *mdp)
717 {
718 	video_unregister_device(mdp->m2m_vdev);
719 }
720 
721 void mdp_m2m_job_finish(struct mdp_m2m_ctx *ctx)
722 {
723 	enum vb2_buffer_state vb_state = VB2_BUF_STATE_DONE;
724 
725 	mdp_m2m_process_done(ctx, vb_state);
726 }
727