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(¶m.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(¶m.outputs[0], frame, &dst_vb->vb2_buf); 89 90 ret = mdp_vpu_process(&ctx->mdp_dev->vpu, ¶m); 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 = ¶m; 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