775 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Samsung S5P/EXYNOS4 SoC series FIMC (video postprocessor) driver4 *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 31static 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 else36 return FMT_FLAGS_M2M_OUT;37}38 39void 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. */59static 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 73static 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 80static 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 89static 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 159dma_unlock:160 spin_unlock_irqrestore(&fimc->slock, flags);161}162 163static void fimc_job_abort(void *priv)164{165 fimc_m2m_shutdown(priv);166}167 168static 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 192static 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 208static 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 215static 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 handlers227 */228static 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 237static 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 251static 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 264static 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 else300 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 310static 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 317static 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 339static 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 else363 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 378static 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 428static 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 else460 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 486static 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 526static 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 548static 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 581static 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 604static 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 the616 * 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 665error_m2m_ctx:666 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);667error_c:668 fimc_ctrls_delete(ctx);669 v4l2_fh_del(&ctx->fh);670error_fh:671 v4l2_fh_exit(&ctx->fh);672 kfree(ctx);673unlock:674 mutex_unlock(&fimc->lock);675 return ret;676}677 678static 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 701static 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 710static const struct v4l2_m2m_ops m2m_ops = {711 .device_run = fimc_device_run,712 .job_abort = fimc_job_abort,713};714 715int 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 755err_vd:756 media_entity_cleanup(&vfd->entity);757err_me:758 v4l2_m2m_release(fimc->m2m.m2m_dev);759 return ret;760}761 762void 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