1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Samsung S5P/EXYNOS4 SoC series FIMC (video postprocessor) driver 4 * 5 * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd. 6 * Sylwester Nawrocki <s.nawrocki@samsung.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/types.h> 12 #include <linux/errno.h> 13 #include <linux/bug.h> 14 #include <linux/interrupt.h> 15 #include <linux/device.h> 16 #include <linux/platform_device.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/list.h> 19 #include <linux/io.h> 20 #include <linux/slab.h> 21 #include <linux/clk.h> 22 #include <media/v4l2-ioctl.h> 23 #include <media/videobuf2-v4l2.h> 24 #include <media/videobuf2-dma-contig.h> 25 26 #include "common.h" 27 #include "fimc-core.h" 28 #include "fimc-reg.h" 29 #include "media-dev.h" 30 31 static unsigned int get_m2m_fmt_flags(unsigned int stream_type) 32 { 33 if (stream_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 34 return FMT_FLAGS_M2M_IN; 35 else 36 return FMT_FLAGS_M2M_OUT; 37 } 38 39 void fimc_m2m_job_finish(struct fimc_ctx *ctx, int vb_state) 40 { 41 struct vb2_v4l2_buffer *src_vb, *dst_vb; 42 43 if (!ctx || !ctx->fh.m2m_ctx) 44 return; 45 46 src_vb = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 47 dst_vb = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 48 49 if (src_vb) 50 v4l2_m2m_buf_done(src_vb, vb_state); 51 if (dst_vb) 52 v4l2_m2m_buf_done(dst_vb, vb_state); 53 if (src_vb && dst_vb) 54 v4l2_m2m_job_finish(ctx->fimc_dev->m2m.m2m_dev, 55 ctx->fh.m2m_ctx); 56 } 57 58 /* Complete the transaction which has been scheduled for execution. */ 59 static void fimc_m2m_shutdown(struct fimc_ctx *ctx) 60 { 61 struct fimc_dev *fimc = ctx->fimc_dev; 62 63 if (!fimc_m2m_pending(fimc)) 64 return; 65 66 fimc_ctx_state_set(FIMC_CTX_SHUT, ctx); 67 68 wait_event_timeout(fimc->irq_queue, 69 !fimc_ctx_state_is_set(FIMC_CTX_SHUT, ctx), 70 FIMC_SHUTDOWN_TIMEOUT); 71 } 72 73 static int start_streaming(struct vb2_queue *q, unsigned int count) 74 { 75 struct fimc_ctx *ctx = q->drv_priv; 76 77 return pm_runtime_resume_and_get(&ctx->fimc_dev->pdev->dev); 78 } 79 80 static void stop_streaming(struct vb2_queue *q) 81 { 82 struct fimc_ctx *ctx = q->drv_priv; 83 84 fimc_m2m_shutdown(ctx); 85 fimc_m2m_job_finish(ctx, VB2_BUF_STATE_ERROR); 86 pm_runtime_put(&ctx->fimc_dev->pdev->dev); 87 } 88 89 static void fimc_device_run(void *priv) 90 { 91 struct vb2_v4l2_buffer *src_vb, *dst_vb; 92 struct fimc_ctx *ctx = priv; 93 struct fimc_frame *sf, *df; 94 struct fimc_dev *fimc; 95 unsigned long flags; 96 int ret; 97 98 if (WARN(!ctx, "Null context\n")) 99 return; 100 101 fimc = ctx->fimc_dev; 102 spin_lock_irqsave(&fimc->slock, flags); 103 104 set_bit(ST_M2M_PEND, &fimc->state); 105 sf = &ctx->s_frame; 106 df = &ctx->d_frame; 107 108 if (ctx->state & FIMC_PARAMS) { 109 /* Prepare the DMA offsets for scaler */ 110 fimc_prepare_dma_offset(ctx, sf); 111 fimc_prepare_dma_offset(ctx, df); 112 } 113 114 src_vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 115 ret = fimc_prepare_addr(ctx, &src_vb->vb2_buf, sf, &sf->addr); 116 if (ret) 117 goto dma_unlock; 118 119 dst_vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 120 ret = fimc_prepare_addr(ctx, &dst_vb->vb2_buf, df, &df->addr); 121 if (ret) 122 goto dma_unlock; 123 124 dst_vb->vb2_buf.timestamp = src_vb->vb2_buf.timestamp; 125 dst_vb->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK; 126 dst_vb->flags |= 127 src_vb->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK; 128 129 /* Reconfigure hardware if the context has changed. */ 130 if (fimc->m2m.ctx != ctx) { 131 ctx->state |= FIMC_PARAMS; 132 fimc->m2m.ctx = ctx; 133 } 134 135 if (ctx->state & FIMC_PARAMS) { 136 fimc_set_yuv_order(ctx); 137 fimc_hw_set_input_path(ctx); 138 fimc_hw_set_in_dma(ctx); 139 ret = fimc_set_scaler_info(ctx); 140 if (ret) 141 goto dma_unlock; 142 fimc_hw_set_prescaler(ctx); 143 fimc_hw_set_mainscaler(ctx); 144 fimc_hw_set_target_format(ctx); 145 fimc_hw_set_rotation(ctx); 146 fimc_hw_set_effect(ctx); 147 fimc_hw_set_out_dma(ctx); 148 if (fimc->drv_data->alpha_color) 149 fimc_hw_set_rgb_alpha(ctx); 150 fimc_hw_set_output_path(ctx); 151 } 152 fimc_hw_set_input_addr(fimc, &sf->addr); 153 fimc_hw_set_output_addr(fimc, &df->addr, -1); 154 155 fimc_activate_capture(ctx); 156 ctx->state &= (FIMC_CTX_M2M | FIMC_CTX_CAP); 157 fimc_hw_activate_input_dma(fimc, true); 158 159 dma_unlock: 160 spin_unlock_irqrestore(&fimc->slock, flags); 161 } 162 163 static void fimc_job_abort(void *priv) 164 { 165 fimc_m2m_shutdown(priv); 166 } 167 168 static int fimc_queue_setup(struct vb2_queue *vq, 169 unsigned int *num_buffers, unsigned int *num_planes, 170 unsigned int sizes[], struct device *alloc_devs[]) 171 { 172 struct fimc_ctx *ctx = vb2_get_drv_priv(vq); 173 const struct fimc_frame *f; 174 int i; 175 176 f = ctx_get_frame(ctx, vq->type); 177 if (IS_ERR(f)) 178 return PTR_ERR(f); 179 /* 180 * Return number of non-contiguous planes (plane buffers) 181 * depending on the configured color format. 182 */ 183 if (!f->fmt) 184 return -EINVAL; 185 186 *num_planes = f->fmt->memplanes; 187 for (i = 0; i < f->fmt->memplanes; i++) 188 sizes[i] = f->payload[i]; 189 return 0; 190 } 191 192 static int fimc_buf_prepare(struct vb2_buffer *vb) 193 { 194 struct fimc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 195 const struct fimc_frame *frame; 196 int i; 197 198 frame = ctx_get_frame(ctx, vb->vb2_queue->type); 199 if (IS_ERR(frame)) 200 return PTR_ERR(frame); 201 202 for (i = 0; i < frame->fmt->memplanes; i++) 203 vb2_set_plane_payload(vb, i, frame->payload[i]); 204 205 return 0; 206 } 207 208 static void fimc_buf_queue(struct vb2_buffer *vb) 209 { 210 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 211 struct fimc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 212 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 213 } 214 215 static const struct vb2_ops fimc_qops = { 216 .queue_setup = fimc_queue_setup, 217 .buf_prepare = fimc_buf_prepare, 218 .buf_queue = fimc_buf_queue, 219 .wait_prepare = vb2_ops_wait_prepare, 220 .wait_finish = vb2_ops_wait_finish, 221 .stop_streaming = stop_streaming, 222 .start_streaming = start_streaming, 223 }; 224 225 /* 226 * V4L2 ioctl handlers 227 */ 228 static int fimc_m2m_querycap(struct file *file, void *fh, 229 struct v4l2_capability *cap) 230 { 231 struct fimc_dev *fimc = video_drvdata(file); 232 233 __fimc_vidioc_querycap(&fimc->pdev->dev, cap); 234 return 0; 235 } 236 237 static int fimc_m2m_enum_fmt(struct file *file, void *priv, 238 struct v4l2_fmtdesc *f) 239 { 240 const struct fimc_fmt *fmt; 241 242 fmt = fimc_find_format(NULL, NULL, get_m2m_fmt_flags(f->type), 243 f->index); 244 if (!fmt) 245 return -EINVAL; 246 247 f->pixelformat = fmt->fourcc; 248 return 0; 249 } 250 251 static int fimc_m2m_g_fmt_mplane(struct file *file, void *fh, 252 struct v4l2_format *f) 253 { 254 struct fimc_ctx *ctx = fh_to_ctx(fh); 255 const struct fimc_frame *frame = ctx_get_frame(ctx, f->type); 256 257 if (IS_ERR(frame)) 258 return PTR_ERR(frame); 259 260 __fimc_get_format(frame, f); 261 return 0; 262 } 263 264 static int fimc_try_fmt_mplane(struct fimc_ctx *ctx, struct v4l2_format *f) 265 { 266 struct fimc_dev *fimc = ctx->fimc_dev; 267 const struct fimc_variant *variant = fimc->variant; 268 struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp; 269 const struct fimc_fmt *fmt; 270 u32 max_w, mod_x, mod_y; 271 272 if (!IS_M2M(f->type)) 273 return -EINVAL; 274 275 fmt = fimc_find_format(&pix->pixelformat, NULL, 276 get_m2m_fmt_flags(f->type), 0); 277 if (WARN(fmt == NULL, "Pixel format lookup failed")) 278 return -EINVAL; 279 280 if (pix->field == V4L2_FIELD_ANY) 281 pix->field = V4L2_FIELD_NONE; 282 else if (pix->field != V4L2_FIELD_NONE) 283 return -EINVAL; 284 285 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 286 max_w = variant->pix_limit->scaler_dis_w; 287 mod_x = ffs(variant->min_inp_pixsize) - 1; 288 } else { 289 max_w = variant->pix_limit->out_rot_dis_w; 290 mod_x = ffs(variant->min_out_pixsize) - 1; 291 } 292 293 if (tiled_fmt(fmt)) { 294 mod_x = 6; /* 64 x 32 pixels tile */ 295 mod_y = 5; 296 } else { 297 if (variant->min_vsize_align == 1) 298 mod_y = fimc_fmt_is_rgb(fmt->color) ? 0 : 1; 299 else 300 mod_y = ffs(variant->min_vsize_align) - 1; 301 } 302 303 v4l_bound_align_image(&pix->width, 16, max_w, mod_x, 304 &pix->height, 8, variant->pix_limit->scaler_dis_w, mod_y, 0); 305 306 fimc_adjust_mplane_format(fmt, pix->width, pix->height, &f->fmt.pix_mp); 307 return 0; 308 } 309 310 static int fimc_m2m_try_fmt_mplane(struct file *file, void *fh, 311 struct v4l2_format *f) 312 { 313 struct fimc_ctx *ctx = fh_to_ctx(fh); 314 return fimc_try_fmt_mplane(ctx, f); 315 } 316 317 static void __set_frame_format(struct fimc_frame *frame, 318 const struct fimc_fmt *fmt, 319 const struct v4l2_pix_format_mplane *pixm) 320 { 321 int i; 322 323 for (i = 0; i < fmt->memplanes; i++) { 324 frame->bytesperline[i] = pixm->plane_fmt[i].bytesperline; 325 frame->payload[i] = pixm->plane_fmt[i].sizeimage; 326 } 327 328 frame->f_width = pixm->width; 329 frame->f_height = pixm->height; 330 frame->o_width = pixm->width; 331 frame->o_height = pixm->height; 332 frame->width = pixm->width; 333 frame->height = pixm->height; 334 frame->offs_h = 0; 335 frame->offs_v = 0; 336 frame->fmt = fmt; 337 } 338 339 static int fimc_m2m_s_fmt_mplane(struct file *file, void *fh, 340 struct v4l2_format *f) 341 { 342 struct fimc_ctx *ctx = fh_to_ctx(fh); 343 struct fimc_dev *fimc = ctx->fimc_dev; 344 const struct fimc_fmt *fmt; 345 struct vb2_queue *vq; 346 struct fimc_frame *frame; 347 int ret; 348 349 ret = fimc_try_fmt_mplane(ctx, f); 350 if (ret) 351 return ret; 352 353 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); 354 355 if (vb2_is_busy(vq)) { 356 v4l2_err(&fimc->m2m.vfd, "queue (%d) busy\n", f->type); 357 return -EBUSY; 358 } 359 360 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 361 frame = &ctx->s_frame; 362 else 363 frame = &ctx->d_frame; 364 365 fmt = fimc_find_format(&f->fmt.pix_mp.pixelformat, NULL, 366 get_m2m_fmt_flags(f->type), 0); 367 if (!fmt) 368 return -EINVAL; 369 370 __set_frame_format(frame, fmt, &f->fmt.pix_mp); 371 372 /* Update RGB Alpha control state and value range */ 373 fimc_alpha_ctrl_update(ctx); 374 375 return 0; 376 } 377 378 static int fimc_m2m_g_selection(struct file *file, void *fh, 379 struct v4l2_selection *s) 380 { 381 struct fimc_ctx *ctx = fh_to_ctx(fh); 382 const struct fimc_frame *frame; 383 384 frame = ctx_get_frame(ctx, s->type); 385 if (IS_ERR(frame)) 386 return PTR_ERR(frame); 387 388 switch (s->target) { 389 case V4L2_SEL_TGT_CROP: 390 case V4L2_SEL_TGT_CROP_DEFAULT: 391 case V4L2_SEL_TGT_CROP_BOUNDS: 392 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 393 return -EINVAL; 394 break; 395 case V4L2_SEL_TGT_COMPOSE: 396 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 397 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 398 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 399 return -EINVAL; 400 break; 401 default: 402 return -EINVAL; 403 } 404 405 switch (s->target) { 406 case V4L2_SEL_TGT_CROP: 407 case V4L2_SEL_TGT_COMPOSE: 408 s->r.left = frame->offs_h; 409 s->r.top = frame->offs_v; 410 s->r.width = frame->width; 411 s->r.height = frame->height; 412 break; 413 case V4L2_SEL_TGT_CROP_DEFAULT: 414 case V4L2_SEL_TGT_CROP_BOUNDS: 415 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 416 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 417 s->r.left = 0; 418 s->r.top = 0; 419 s->r.width = frame->o_width; 420 s->r.height = frame->o_height; 421 break; 422 default: 423 return -EINVAL; 424 } 425 return 0; 426 } 427 428 static int fimc_m2m_try_selection(struct fimc_ctx *ctx, 429 struct v4l2_selection *s) 430 { 431 struct fimc_dev *fimc = ctx->fimc_dev; 432 const struct fimc_frame *f; 433 u32 min_size, halign, depth = 0; 434 int i; 435 436 if (s->r.top < 0 || s->r.left < 0) { 437 v4l2_err(&fimc->m2m.vfd, 438 "doesn't support negative values for top & left\n"); 439 return -EINVAL; 440 } 441 if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 442 f = &ctx->d_frame; 443 if (s->target != V4L2_SEL_TGT_COMPOSE) 444 return -EINVAL; 445 } else if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 446 f = &ctx->s_frame; 447 if (s->target != V4L2_SEL_TGT_CROP) 448 return -EINVAL; 449 } else { 450 return -EINVAL; 451 } 452 453 min_size = (f == &ctx->s_frame) ? 454 fimc->variant->min_inp_pixsize : fimc->variant->min_out_pixsize; 455 456 /* Get pixel alignment constraints. */ 457 if (fimc->variant->min_vsize_align == 1) 458 halign = fimc_fmt_is_rgb(f->fmt->color) ? 0 : 1; 459 else 460 halign = ffs(fimc->variant->min_vsize_align) - 1; 461 462 for (i = 0; i < f->fmt->memplanes; i++) 463 depth += f->fmt->depth[i]; 464 465 v4l_bound_align_image(&s->r.width, min_size, f->o_width, 466 ffs(min_size) - 1, 467 &s->r.height, min_size, f->o_height, 468 halign, 64/(ALIGN(depth, 8))); 469 470 /* adjust left/top if cropping rectangle is out of bounds */ 471 if (s->r.left + s->r.width > f->o_width) 472 s->r.left = f->o_width - s->r.width; 473 if (s->r.top + s->r.height > f->o_height) 474 s->r.top = f->o_height - s->r.height; 475 476 s->r.left = round_down(s->r.left, min_size); 477 s->r.top = round_down(s->r.top, fimc->variant->hor_offs_align); 478 479 dbg("l:%d, t:%d, w:%d, h:%d, f_w: %d, f_h: %d", 480 s->r.left, s->r.top, s->r.width, s->r.height, 481 f->f_width, f->f_height); 482 483 return 0; 484 } 485 486 static int fimc_m2m_s_selection(struct file *file, void *fh, 487 struct v4l2_selection *s) 488 { 489 struct fimc_ctx *ctx = fh_to_ctx(fh); 490 struct fimc_dev *fimc = ctx->fimc_dev; 491 struct fimc_frame *f; 492 int ret; 493 494 ret = fimc_m2m_try_selection(ctx, s); 495 if (ret) 496 return ret; 497 498 f = (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ? 499 &ctx->s_frame : &ctx->d_frame; 500 501 /* Check to see if scaling ratio is within supported range */ 502 if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 503 ret = fimc_check_scaler_ratio(ctx, s->r.width, 504 s->r.height, ctx->d_frame.width, 505 ctx->d_frame.height, ctx->rotation); 506 } else { 507 ret = fimc_check_scaler_ratio(ctx, ctx->s_frame.width, 508 ctx->s_frame.height, s->r.width, 509 s->r.height, ctx->rotation); 510 } 511 if (ret) { 512 v4l2_err(&fimc->m2m.vfd, "Out of scaler range\n"); 513 return -EINVAL; 514 } 515 516 f->offs_h = s->r.left; 517 f->offs_v = s->r.top; 518 f->width = s->r.width; 519 f->height = s->r.height; 520 521 fimc_ctx_state_set(FIMC_PARAMS, ctx); 522 523 return 0; 524 } 525 526 static const struct v4l2_ioctl_ops fimc_m2m_ioctl_ops = { 527 .vidioc_querycap = fimc_m2m_querycap, 528 .vidioc_enum_fmt_vid_cap = fimc_m2m_enum_fmt, 529 .vidioc_enum_fmt_vid_out = fimc_m2m_enum_fmt, 530 .vidioc_g_fmt_vid_cap_mplane = fimc_m2m_g_fmt_mplane, 531 .vidioc_g_fmt_vid_out_mplane = fimc_m2m_g_fmt_mplane, 532 .vidioc_try_fmt_vid_cap_mplane = fimc_m2m_try_fmt_mplane, 533 .vidioc_try_fmt_vid_out_mplane = fimc_m2m_try_fmt_mplane, 534 .vidioc_s_fmt_vid_cap_mplane = fimc_m2m_s_fmt_mplane, 535 .vidioc_s_fmt_vid_out_mplane = fimc_m2m_s_fmt_mplane, 536 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 537 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 538 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 539 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 540 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 541 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 542 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 543 .vidioc_g_selection = fimc_m2m_g_selection, 544 .vidioc_s_selection = fimc_m2m_s_selection, 545 546 }; 547 548 static int queue_init(void *priv, struct vb2_queue *src_vq, 549 struct vb2_queue *dst_vq) 550 { 551 struct fimc_ctx *ctx = priv; 552 int ret; 553 554 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 555 src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 556 src_vq->drv_priv = ctx; 557 src_vq->ops = &fimc_qops; 558 src_vq->mem_ops = &vb2_dma_contig_memops; 559 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 560 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 561 src_vq->lock = &ctx->fimc_dev->lock; 562 src_vq->dev = &ctx->fimc_dev->pdev->dev; 563 564 ret = vb2_queue_init(src_vq); 565 if (ret) 566 return ret; 567 568 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 569 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 570 dst_vq->drv_priv = ctx; 571 dst_vq->ops = &fimc_qops; 572 dst_vq->mem_ops = &vb2_dma_contig_memops; 573 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 574 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 575 dst_vq->lock = &ctx->fimc_dev->lock; 576 dst_vq->dev = &ctx->fimc_dev->pdev->dev; 577 578 return vb2_queue_init(dst_vq); 579 } 580 581 static int fimc_m2m_set_default_format(struct fimc_ctx *ctx) 582 { 583 struct v4l2_pix_format_mplane pixm = { 584 .pixelformat = V4L2_PIX_FMT_RGB32, 585 .width = 800, 586 .height = 600, 587 .plane_fmt[0] = { 588 .bytesperline = 800 * 4, 589 .sizeimage = 800 * 4 * 600, 590 }, 591 }; 592 const struct fimc_fmt *fmt; 593 594 fmt = fimc_find_format(&pixm.pixelformat, NULL, FMT_FLAGS_M2M, 0); 595 if (!fmt) 596 return -EINVAL; 597 598 __set_frame_format(&ctx->s_frame, fmt, &pixm); 599 __set_frame_format(&ctx->d_frame, fmt, &pixm); 600 601 return 0; 602 } 603 604 static int fimc_m2m_open(struct file *file) 605 { 606 struct fimc_dev *fimc = video_drvdata(file); 607 struct fimc_ctx *ctx; 608 int ret = -EBUSY; 609 610 pr_debug("pid: %d, state: %#lx\n", task_pid_nr(current), fimc->state); 611 612 if (mutex_lock_interruptible(&fimc->lock)) 613 return -ERESTARTSYS; 614 /* 615 * Don't allow simultaneous open() of the mem-to-mem and the 616 * capture video node that belong to same FIMC IP instance. 617 */ 618 if (test_bit(ST_CAPT_BUSY, &fimc->state)) 619 goto unlock; 620 621 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 622 if (!ctx) { 623 ret = -ENOMEM; 624 goto unlock; 625 } 626 v4l2_fh_init(&ctx->fh, &fimc->m2m.vfd); 627 ctx->fimc_dev = fimc; 628 629 /* Default color format */ 630 ctx->s_frame.fmt = fimc_get_format(0); 631 ctx->d_frame.fmt = fimc_get_format(0); 632 633 ret = fimc_ctrls_create(ctx); 634 if (ret) 635 goto error_fh; 636 637 /* Use separate control handler per file handle */ 638 ctx->fh.ctrl_handler = &ctx->ctrls.handler; 639 file->private_data = &ctx->fh; 640 v4l2_fh_add(&ctx->fh); 641 642 /* Setup the device context for memory-to-memory mode */ 643 ctx->state = FIMC_CTX_M2M; 644 ctx->flags = 0; 645 ctx->in_path = FIMC_IO_DMA; 646 ctx->out_path = FIMC_IO_DMA; 647 ctx->scaler.enabled = 1; 648 649 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(fimc->m2m.m2m_dev, ctx, queue_init); 650 if (IS_ERR(ctx->fh.m2m_ctx)) { 651 ret = PTR_ERR(ctx->fh.m2m_ctx); 652 goto error_c; 653 } 654 655 if (fimc->m2m.refcnt++ == 0) 656 set_bit(ST_M2M_RUN, &fimc->state); 657 658 ret = fimc_m2m_set_default_format(ctx); 659 if (ret < 0) 660 goto error_m2m_ctx; 661 662 mutex_unlock(&fimc->lock); 663 return 0; 664 665 error_m2m_ctx: 666 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 667 error_c: 668 fimc_ctrls_delete(ctx); 669 v4l2_fh_del(&ctx->fh); 670 error_fh: 671 v4l2_fh_exit(&ctx->fh); 672 kfree(ctx); 673 unlock: 674 mutex_unlock(&fimc->lock); 675 return ret; 676 } 677 678 static int fimc_m2m_release(struct file *file) 679 { 680 struct fimc_ctx *ctx = fh_to_ctx(file->private_data); 681 struct fimc_dev *fimc = ctx->fimc_dev; 682 683 dbg("pid: %d, state: 0x%lx, refcnt= %d", 684 task_pid_nr(current), fimc->state, fimc->m2m.refcnt); 685 686 mutex_lock(&fimc->lock); 687 688 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 689 fimc_ctrls_delete(ctx); 690 v4l2_fh_del(&ctx->fh); 691 v4l2_fh_exit(&ctx->fh); 692 693 if (--fimc->m2m.refcnt <= 0) 694 clear_bit(ST_M2M_RUN, &fimc->state); 695 kfree(ctx); 696 697 mutex_unlock(&fimc->lock); 698 return 0; 699 } 700 701 static const struct v4l2_file_operations fimc_m2m_fops = { 702 .owner = THIS_MODULE, 703 .open = fimc_m2m_open, 704 .release = fimc_m2m_release, 705 .poll = v4l2_m2m_fop_poll, 706 .unlocked_ioctl = video_ioctl2, 707 .mmap = v4l2_m2m_fop_mmap, 708 }; 709 710 static const struct v4l2_m2m_ops m2m_ops = { 711 .device_run = fimc_device_run, 712 .job_abort = fimc_job_abort, 713 }; 714 715 int fimc_register_m2m_device(struct fimc_dev *fimc, 716 struct v4l2_device *v4l2_dev) 717 { 718 struct video_device *vfd = &fimc->m2m.vfd; 719 int ret; 720 721 fimc->v4l2_dev = v4l2_dev; 722 723 memset(vfd, 0, sizeof(*vfd)); 724 vfd->fops = &fimc_m2m_fops; 725 vfd->ioctl_ops = &fimc_m2m_ioctl_ops; 726 vfd->v4l2_dev = v4l2_dev; 727 vfd->minor = -1; 728 vfd->release = video_device_release_empty; 729 vfd->lock = &fimc->lock; 730 vfd->vfl_dir = VFL_DIR_M2M; 731 vfd->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M_MPLANE; 732 set_bit(V4L2_FL_QUIRK_INVERTED_CROP, &vfd->flags); 733 734 snprintf(vfd->name, sizeof(vfd->name), "fimc.%d.m2m", fimc->id); 735 video_set_drvdata(vfd, fimc); 736 737 fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops); 738 if (IS_ERR(fimc->m2m.m2m_dev)) { 739 v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device\n"); 740 return PTR_ERR(fimc->m2m.m2m_dev); 741 } 742 743 ret = media_entity_pads_init(&vfd->entity, 0, NULL); 744 if (ret) 745 goto err_me; 746 747 ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1); 748 if (ret) 749 goto err_vd; 750 751 v4l2_info(v4l2_dev, "Registered %s as /dev/%s\n", 752 vfd->name, video_device_node_name(vfd)); 753 return 0; 754 755 err_vd: 756 media_entity_cleanup(&vfd->entity); 757 err_me: 758 v4l2_m2m_release(fimc->m2m.m2m_dev); 759 return ret; 760 } 761 762 void fimc_unregister_m2m_device(struct fimc_dev *fimc) 763 { 764 if (!fimc) 765 return; 766 767 if (fimc->m2m.m2m_dev) 768 v4l2_m2m_release(fimc->m2m.m2m_dev); 769 770 if (video_is_registered(&fimc->m2m.vfd)) { 771 video_unregister_device(&fimc->m2m.vfd); 772 media_entity_cleanup(&fimc->m2m.vfd.entity); 773 } 774 } 775