1 // SPDX-License-Identifier: GPL-2.0+
3 * Video Capture Subdev for Freescale i.MX5/6 SOC
5 * Copyright (c) 2012-2016 Mentor Graphics Inc.
7 #include <linux/delay.h>
9 #include <linux/module.h>
10 #include <linux/pinctrl/consumer.h>
11 #include <linux/platform_device.h>
12 #include <linux/sched.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
15 #include <linux/timer.h>
16 #include <media/v4l2-ctrls.h>
17 #include <media/v4l2-device.h>
18 #include <media/v4l2-event.h>
19 #include <media/v4l2-fwnode.h>
20 #include <media/v4l2-ioctl.h>
21 #include <media/v4l2-mc.h>
22 #include <media/v4l2-subdev.h>
23 #include <media/videobuf2-dma-contig.h>
24 #include <video/imx-ipu-v3.h>
25 #include <media/imx.h>
26 #include "imx-media.h"
28 #define IMX_CAPTURE_NAME "imx-capture"
31 struct imx_media_dev *md; /* Media device */
32 struct device *dev; /* Physical device */
34 struct imx_media_video_dev vdev; /* Video device */
35 struct media_pad vdev_pad; /* Video device pad */
37 struct v4l2_subdev *src_sd; /* Source subdev */
38 int src_sd_pad; /* Source subdev pad */
40 struct mutex mutex; /* Protect vdev operations */
42 struct vb2_queue q; /* The videobuf2 queue */
43 struct list_head ready_q; /* List of queued buffers */
44 spinlock_t q_lock; /* Protect ready_q */
46 struct v4l2_ctrl_handler ctrl_hdlr; /* Controls inherited from subdevs */
48 bool legacy_api; /* Use the legacy (pre-MC) API */
51 #define to_capture_priv(v) container_of(v, struct capture_priv, vdev)
53 /* In bytes, per queue */
54 #define VID_MEM_LIMIT SZ_64M
56 /* -----------------------------------------------------------------------------
57 * MC-Centric Video IOCTLs
60 static const struct imx_media_pixfmt *capture_find_format(u32 code, u32 fourcc)
62 const struct imx_media_pixfmt *cc;
64 cc = imx_media_find_ipu_format(code, PIXFMT_SEL_YUV_RGB);
66 enum imx_pixfmt_sel fmt_sel = cc->cs == IPUV3_COLORSPACE_YUV
67 ? PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
69 cc = imx_media_find_pixel_format(fourcc, fmt_sel);
71 imx_media_enum_pixel_formats(&fourcc, 0, fmt_sel, 0);
72 cc = imx_media_find_pixel_format(fourcc, fmt_sel);
78 return imx_media_find_mbus_format(code, PIXFMT_SEL_ANY);
81 static int capture_querycap(struct file *file, void *fh,
82 struct v4l2_capability *cap)
84 struct capture_priv *priv = video_drvdata(file);
86 strscpy(cap->driver, IMX_CAPTURE_NAME, sizeof(cap->driver));
87 strscpy(cap->card, IMX_CAPTURE_NAME, sizeof(cap->card));
88 snprintf(cap->bus_info, sizeof(cap->bus_info),
89 "platform:%s", dev_name(priv->dev));
94 static int capture_enum_fmt_vid_cap(struct file *file, void *fh,
95 struct v4l2_fmtdesc *f)
97 return imx_media_enum_pixel_formats(&f->pixelformat, f->index,
98 PIXFMT_SEL_ANY, f->mbus_code);
101 static int capture_enum_framesizes(struct file *file, void *fh,
102 struct v4l2_frmsizeenum *fsize)
104 const struct imx_media_pixfmt *cc;
106 if (fsize->index > 0)
109 cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
114 * TODO: The constraints are hardware-specific and may depend on the
115 * pixel format. This should come from the driver using
118 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
119 fsize->stepwise.min_width = 1;
120 fsize->stepwise.max_width = 65535;
121 fsize->stepwise.min_height = 1;
122 fsize->stepwise.max_height = 65535;
123 fsize->stepwise.step_width = 1;
124 fsize->stepwise.step_height = 1;
129 static int capture_g_fmt_vid_cap(struct file *file, void *fh,
130 struct v4l2_format *f)
132 struct capture_priv *priv = video_drvdata(file);
134 f->fmt.pix = priv->vdev.fmt;
139 static const struct imx_media_pixfmt *
140 __capture_try_fmt(struct v4l2_pix_format *pixfmt, struct v4l2_rect *compose)
142 struct v4l2_mbus_framefmt fmt_src;
143 const struct imx_media_pixfmt *cc;
146 * Find the pixel format, default to the first supported format if not
149 cc = imx_media_find_pixel_format(pixfmt->pixelformat, PIXFMT_SEL_ANY);
151 imx_media_enum_pixel_formats(&pixfmt->pixelformat, 0,
153 cc = imx_media_find_pixel_format(pixfmt->pixelformat,
157 /* Allow IDMAC interweave but enforce field order from source. */
158 if (V4L2_FIELD_IS_INTERLACED(pixfmt->field)) {
159 switch (pixfmt->field) {
160 case V4L2_FIELD_SEQ_TB:
161 pixfmt->field = V4L2_FIELD_INTERLACED_TB;
163 case V4L2_FIELD_SEQ_BT:
164 pixfmt->field = V4L2_FIELD_INTERLACED_BT;
171 v4l2_fill_mbus_format(&fmt_src, pixfmt, 0);
172 imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src, cc);
175 compose->width = fmt_src.width;
176 compose->height = fmt_src.height;
182 static int capture_try_fmt_vid_cap(struct file *file, void *fh,
183 struct v4l2_format *f)
185 __capture_try_fmt(&f->fmt.pix, NULL);
189 static int capture_s_fmt_vid_cap(struct file *file, void *fh,
190 struct v4l2_format *f)
192 struct capture_priv *priv = video_drvdata(file);
193 const struct imx_media_pixfmt *cc;
195 if (vb2_is_busy(&priv->q)) {
196 dev_err(priv->dev, "%s queue busy\n", __func__);
200 cc = __capture_try_fmt(&f->fmt.pix, &priv->vdev.compose);
203 priv->vdev.fmt = f->fmt.pix;
208 static int capture_g_selection(struct file *file, void *fh,
209 struct v4l2_selection *s)
211 struct capture_priv *priv = video_drvdata(file);
214 case V4L2_SEL_TGT_COMPOSE:
215 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
216 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
217 /* The compose rectangle is fixed to the source format. */
218 s->r = priv->vdev.compose;
220 case V4L2_SEL_TGT_COMPOSE_PADDED:
222 * The hardware writes with a configurable but fixed DMA burst
223 * size. If the source format width is not burst size aligned,
224 * the written frame contains padding to the right.
228 s->r.width = priv->vdev.fmt.width;
229 s->r.height = priv->vdev.fmt.height;
238 static int capture_subscribe_event(struct v4l2_fh *fh,
239 const struct v4l2_event_subscription *sub)
242 case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
243 return v4l2_event_subscribe(fh, sub, 0, NULL);
249 static const struct v4l2_ioctl_ops capture_ioctl_ops = {
250 .vidioc_querycap = capture_querycap,
252 .vidioc_enum_fmt_vid_cap = capture_enum_fmt_vid_cap,
253 .vidioc_enum_framesizes = capture_enum_framesizes,
255 .vidioc_g_fmt_vid_cap = capture_g_fmt_vid_cap,
256 .vidioc_try_fmt_vid_cap = capture_try_fmt_vid_cap,
257 .vidioc_s_fmt_vid_cap = capture_s_fmt_vid_cap,
259 .vidioc_g_selection = capture_g_selection,
261 .vidioc_reqbufs = vb2_ioctl_reqbufs,
262 .vidioc_create_bufs = vb2_ioctl_create_bufs,
263 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
264 .vidioc_querybuf = vb2_ioctl_querybuf,
265 .vidioc_qbuf = vb2_ioctl_qbuf,
266 .vidioc_dqbuf = vb2_ioctl_dqbuf,
267 .vidioc_expbuf = vb2_ioctl_expbuf,
268 .vidioc_streamon = vb2_ioctl_streamon,
269 .vidioc_streamoff = vb2_ioctl_streamoff,
271 .vidioc_subscribe_event = capture_subscribe_event,
272 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
275 /* -----------------------------------------------------------------------------
276 * Legacy Video IOCTLs
279 static int capture_legacy_enum_framesizes(struct file *file, void *fh,
280 struct v4l2_frmsizeenum *fsize)
282 struct capture_priv *priv = video_drvdata(file);
283 const struct imx_media_pixfmt *cc;
284 struct v4l2_subdev_frame_size_enum fse = {
285 .index = fsize->index,
286 .pad = priv->src_sd_pad,
287 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
291 cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
295 fse.code = cc->codes ? cc->codes[0] : 0;
297 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_size, NULL, &fse);
301 if (fse.min_width == fse.max_width &&
302 fse.min_height == fse.max_height) {
303 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
304 fsize->discrete.width = fse.min_width;
305 fsize->discrete.height = fse.min_height;
307 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
308 fsize->stepwise.min_width = fse.min_width;
309 fsize->stepwise.max_width = fse.max_width;
310 fsize->stepwise.min_height = fse.min_height;
311 fsize->stepwise.max_height = fse.max_height;
312 fsize->stepwise.step_width = 1;
313 fsize->stepwise.step_height = 1;
319 static int capture_legacy_enum_frameintervals(struct file *file, void *fh,
320 struct v4l2_frmivalenum *fival)
322 struct capture_priv *priv = video_drvdata(file);
323 const struct imx_media_pixfmt *cc;
324 struct v4l2_subdev_frame_interval_enum fie = {
325 .index = fival->index,
326 .pad = priv->src_sd_pad,
327 .width = fival->width,
328 .height = fival->height,
329 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
333 cc = imx_media_find_pixel_format(fival->pixel_format, PIXFMT_SEL_ANY);
337 fie.code = cc->codes ? cc->codes[0] : 0;
339 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_interval,
344 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
345 fival->discrete = fie.interval;
350 static int capture_legacy_enum_fmt_vid_cap(struct file *file, void *fh,
351 struct v4l2_fmtdesc *f)
353 struct capture_priv *priv = video_drvdata(file);
354 const struct imx_media_pixfmt *cc_src;
355 struct v4l2_subdev_format fmt_src = {
356 .pad = priv->src_sd_pad,
357 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
362 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
364 dev_err(priv->dev, "failed to get src_sd format\n");
368 cc_src = imx_media_find_ipu_format(fmt_src.format.code,
371 enum imx_pixfmt_sel fmt_sel =
372 (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
373 PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
375 ret = imx_media_enum_pixel_formats(&fourcc, f->index, fmt_sel,
380 cc_src = imx_media_find_mbus_format(fmt_src.format.code,
382 if (WARN_ON(!cc_src))
387 fourcc = cc_src->fourcc;
390 f->pixelformat = fourcc;
395 static const struct imx_media_pixfmt *
396 __capture_legacy_try_fmt(struct capture_priv *priv,
397 struct v4l2_subdev_format *fmt_src,
398 struct v4l2_pix_format *pixfmt)
400 const struct imx_media_pixfmt *cc;
402 cc = capture_find_format(fmt_src->format.code, pixfmt->pixelformat);
406 /* allow IDMAC interweave but enforce field order from source */
407 if (V4L2_FIELD_IS_INTERLACED(pixfmt->field)) {
408 switch (fmt_src->format.field) {
409 case V4L2_FIELD_SEQ_TB:
410 fmt_src->format.field = V4L2_FIELD_INTERLACED_TB;
412 case V4L2_FIELD_SEQ_BT:
413 fmt_src->format.field = V4L2_FIELD_INTERLACED_BT;
420 imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src->format, cc);
425 static int capture_legacy_try_fmt_vid_cap(struct file *file, void *fh,
426 struct v4l2_format *f)
428 struct capture_priv *priv = video_drvdata(file);
429 struct v4l2_subdev_format fmt_src = {
430 .pad = priv->src_sd_pad,
431 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
435 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
439 if (!__capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix))
445 static int capture_legacy_s_fmt_vid_cap(struct file *file, void *fh,
446 struct v4l2_format *f)
448 struct capture_priv *priv = video_drvdata(file);
449 struct v4l2_subdev_format fmt_src = {
450 .pad = priv->src_sd_pad,
451 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
453 const struct imx_media_pixfmt *cc;
456 if (vb2_is_busy(&priv->q)) {
457 dev_err(priv->dev, "%s queue busy\n", __func__);
461 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
465 cc = __capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix);
470 priv->vdev.fmt = f->fmt.pix;
471 priv->vdev.compose.width = fmt_src.format.width;
472 priv->vdev.compose.height = fmt_src.format.height;
477 static int capture_legacy_querystd(struct file *file, void *fh,
480 struct capture_priv *priv = video_drvdata(file);
482 return v4l2_subdev_call(priv->src_sd, video, querystd, std);
485 static int capture_legacy_g_std(struct file *file, void *fh, v4l2_std_id *std)
487 struct capture_priv *priv = video_drvdata(file);
489 return v4l2_subdev_call(priv->src_sd, video, g_std, std);
492 static int capture_legacy_s_std(struct file *file, void *fh, v4l2_std_id std)
494 struct capture_priv *priv = video_drvdata(file);
496 if (vb2_is_busy(&priv->q))
499 return v4l2_subdev_call(priv->src_sd, video, s_std, std);
502 static int capture_legacy_g_parm(struct file *file, void *fh,
503 struct v4l2_streamparm *a)
505 struct capture_priv *priv = video_drvdata(file);
506 struct v4l2_subdev_frame_interval fi = {
507 .pad = priv->src_sd_pad,
511 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
514 ret = v4l2_subdev_call(priv->src_sd, video, g_frame_interval, &fi);
518 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
519 a->parm.capture.timeperframe = fi.interval;
524 static int capture_legacy_s_parm(struct file *file, void *fh,
525 struct v4l2_streamparm *a)
527 struct capture_priv *priv = video_drvdata(file);
528 struct v4l2_subdev_frame_interval fi = {
529 .pad = priv->src_sd_pad,
533 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
536 fi.interval = a->parm.capture.timeperframe;
537 ret = v4l2_subdev_call(priv->src_sd, video, s_frame_interval, &fi);
541 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
542 a->parm.capture.timeperframe = fi.interval;
547 static int capture_legacy_subscribe_event(struct v4l2_fh *fh,
548 const struct v4l2_event_subscription *sub)
551 case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
552 return v4l2_event_subscribe(fh, sub, 0, NULL);
553 case V4L2_EVENT_SOURCE_CHANGE:
554 return v4l2_src_change_event_subscribe(fh, sub);
555 case V4L2_EVENT_CTRL:
556 return v4l2_ctrl_subscribe_event(fh, sub);
562 static const struct v4l2_ioctl_ops capture_legacy_ioctl_ops = {
563 .vidioc_querycap = capture_querycap,
565 .vidioc_enum_framesizes = capture_legacy_enum_framesizes,
566 .vidioc_enum_frameintervals = capture_legacy_enum_frameintervals,
568 .vidioc_enum_fmt_vid_cap = capture_legacy_enum_fmt_vid_cap,
569 .vidioc_g_fmt_vid_cap = capture_g_fmt_vid_cap,
570 .vidioc_try_fmt_vid_cap = capture_legacy_try_fmt_vid_cap,
571 .vidioc_s_fmt_vid_cap = capture_legacy_s_fmt_vid_cap,
573 .vidioc_querystd = capture_legacy_querystd,
574 .vidioc_g_std = capture_legacy_g_std,
575 .vidioc_s_std = capture_legacy_s_std,
577 .vidioc_g_selection = capture_g_selection,
579 .vidioc_g_parm = capture_legacy_g_parm,
580 .vidioc_s_parm = capture_legacy_s_parm,
582 .vidioc_reqbufs = vb2_ioctl_reqbufs,
583 .vidioc_create_bufs = vb2_ioctl_create_bufs,
584 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
585 .vidioc_querybuf = vb2_ioctl_querybuf,
586 .vidioc_qbuf = vb2_ioctl_qbuf,
587 .vidioc_dqbuf = vb2_ioctl_dqbuf,
588 .vidioc_expbuf = vb2_ioctl_expbuf,
589 .vidioc_streamon = vb2_ioctl_streamon,
590 .vidioc_streamoff = vb2_ioctl_streamoff,
592 .vidioc_subscribe_event = capture_legacy_subscribe_event,
593 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
596 /* -----------------------------------------------------------------------------
600 static int capture_queue_setup(struct vb2_queue *vq,
601 unsigned int *nbuffers,
602 unsigned int *nplanes,
603 unsigned int sizes[],
604 struct device *alloc_devs[])
606 struct capture_priv *priv = vb2_get_drv_priv(vq);
607 struct v4l2_pix_format *pix = &priv->vdev.fmt;
608 unsigned int count = *nbuffers;
610 if (vq->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
614 if (*nplanes != 1 || sizes[0] < pix->sizeimage)
616 count += vq->num_buffers;
619 count = min_t(__u32, VID_MEM_LIMIT / pix->sizeimage, count);
622 *nbuffers = (count < vq->num_buffers) ? 0 :
623 count - vq->num_buffers;
628 sizes[0] = pix->sizeimage;
633 static int capture_buf_init(struct vb2_buffer *vb)
635 struct imx_media_buffer *buf = to_imx_media_vb(vb);
637 INIT_LIST_HEAD(&buf->list);
642 static int capture_buf_prepare(struct vb2_buffer *vb)
644 struct vb2_queue *vq = vb->vb2_queue;
645 struct capture_priv *priv = vb2_get_drv_priv(vq);
646 struct v4l2_pix_format *pix = &priv->vdev.fmt;
648 if (vb2_plane_size(vb, 0) < pix->sizeimage) {
650 "data will not fit into plane (%lu < %lu)\n",
651 vb2_plane_size(vb, 0), (long)pix->sizeimage);
655 vb2_set_plane_payload(vb, 0, pix->sizeimage);
660 static void capture_buf_queue(struct vb2_buffer *vb)
662 struct capture_priv *priv = vb2_get_drv_priv(vb->vb2_queue);
663 struct imx_media_buffer *buf = to_imx_media_vb(vb);
666 spin_lock_irqsave(&priv->q_lock, flags);
668 list_add_tail(&buf->list, &priv->ready_q);
670 spin_unlock_irqrestore(&priv->q_lock, flags);
673 static int capture_validate_fmt(struct capture_priv *priv)
675 struct v4l2_subdev_format fmt_src = {
676 .pad = priv->src_sd_pad,
677 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
679 const struct imx_media_pixfmt *cc;
682 /* Retrieve the media bus format on the source subdev. */
683 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
688 * Verify that the media bus size matches the size set on the video
689 * node. It is sufficient to check the compose rectangle size without
690 * checking the rounded size from vdev.fmt, as the rounded size is
691 * derived directly from the compose rectangle size, and will thus
692 * always match if the compose rectangle matches.
694 if (priv->vdev.compose.width != fmt_src.format.width ||
695 priv->vdev.compose.height != fmt_src.format.height)
699 * Verify that the media bus code is compatible with the pixel format
700 * set on the video node.
702 cc = capture_find_format(fmt_src.format.code, 0);
703 if (!cc || priv->vdev.cc->cs != cc->cs)
709 static int capture_start_streaming(struct vb2_queue *vq, unsigned int count)
711 struct capture_priv *priv = vb2_get_drv_priv(vq);
712 struct imx_media_buffer *buf, *tmp;
716 ret = capture_validate_fmt(priv);
718 dev_err(priv->dev, "capture format not valid\n");
722 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
725 dev_err(priv->dev, "pipeline start failed with %d\n", ret);
732 spin_lock_irqsave(&priv->q_lock, flags);
733 list_for_each_entry_safe(buf, tmp, &priv->ready_q, list) {
734 list_del(&buf->list);
735 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_QUEUED);
737 spin_unlock_irqrestore(&priv->q_lock, flags);
741 static void capture_stop_streaming(struct vb2_queue *vq)
743 struct capture_priv *priv = vb2_get_drv_priv(vq);
744 struct imx_media_buffer *frame;
745 struct imx_media_buffer *tmp;
749 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
752 dev_warn(priv->dev, "pipeline stop failed with %d\n", ret);
754 /* release all active buffers */
755 spin_lock_irqsave(&priv->q_lock, flags);
756 list_for_each_entry_safe(frame, tmp, &priv->ready_q, list) {
757 list_del(&frame->list);
758 vb2_buffer_done(&frame->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
760 spin_unlock_irqrestore(&priv->q_lock, flags);
763 static const struct vb2_ops capture_qops = {
764 .queue_setup = capture_queue_setup,
765 .buf_init = capture_buf_init,
766 .buf_prepare = capture_buf_prepare,
767 .buf_queue = capture_buf_queue,
768 .wait_prepare = vb2_ops_wait_prepare,
769 .wait_finish = vb2_ops_wait_finish,
770 .start_streaming = capture_start_streaming,
771 .stop_streaming = capture_stop_streaming,
774 /* -----------------------------------------------------------------------------
778 static int capture_open(struct file *file)
780 struct capture_priv *priv = video_drvdata(file);
781 struct video_device *vfd = priv->vdev.vfd;
784 if (mutex_lock_interruptible(&priv->mutex))
787 ret = v4l2_fh_open(file);
789 dev_err(priv->dev, "v4l2_fh_open failed\n");
793 ret = v4l2_pipeline_pm_get(&vfd->entity);
795 v4l2_fh_release(file);
798 mutex_unlock(&priv->mutex);
802 static int capture_release(struct file *file)
804 struct capture_priv *priv = video_drvdata(file);
805 struct video_device *vfd = priv->vdev.vfd;
806 struct vb2_queue *vq = &priv->q;
808 mutex_lock(&priv->mutex);
810 if (file->private_data == vq->owner) {
811 vb2_queue_release(vq);
815 v4l2_pipeline_pm_put(&vfd->entity);
817 v4l2_fh_release(file);
818 mutex_unlock(&priv->mutex);
822 static const struct v4l2_file_operations capture_fops = {
823 .owner = THIS_MODULE,
824 .open = capture_open,
825 .release = capture_release,
826 .poll = vb2_fop_poll,
827 .unlocked_ioctl = video_ioctl2,
828 .mmap = vb2_fop_mmap,
831 /* -----------------------------------------------------------------------------
835 struct imx_media_buffer *
836 imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev)
838 struct capture_priv *priv = to_capture_priv(vdev);
839 struct imx_media_buffer *buf = NULL;
842 spin_lock_irqsave(&priv->q_lock, flags);
844 /* get next queued buffer */
845 if (!list_empty(&priv->ready_q)) {
846 buf = list_entry(priv->ready_q.next, struct imx_media_buffer,
848 list_del(&buf->list);
851 spin_unlock_irqrestore(&priv->q_lock, flags);
855 EXPORT_SYMBOL_GPL(imx_media_capture_device_next_buf);
857 void imx_media_capture_device_error(struct imx_media_video_dev *vdev)
859 struct capture_priv *priv = to_capture_priv(vdev);
860 struct vb2_queue *vq = &priv->q;
863 if (!vb2_is_streaming(vq))
866 spin_lock_irqsave(&priv->q_lock, flags);
868 spin_unlock_irqrestore(&priv->q_lock, flags);
870 EXPORT_SYMBOL_GPL(imx_media_capture_device_error);
872 static int capture_init_format(struct capture_priv *priv)
874 struct v4l2_subdev_format fmt_src = {
875 .pad = priv->src_sd_pad,
876 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
878 struct imx_media_video_dev *vdev = &priv->vdev;
881 if (priv->legacy_api) {
882 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL,
885 dev_err(priv->dev, "failed to get source format\n");
889 fmt_src.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
890 fmt_src.format.width = IMX_MEDIA_DEF_PIX_WIDTH;
891 fmt_src.format.height = IMX_MEDIA_DEF_PIX_HEIGHT;
894 imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt, &fmt_src.format, NULL);
895 vdev->compose.width = fmt_src.format.width;
896 vdev->compose.height = fmt_src.format.height;
898 vdev->cc = imx_media_find_pixel_format(vdev->fmt.pixelformat,
904 int imx_media_capture_device_register(struct imx_media_video_dev *vdev,
907 struct capture_priv *priv = to_capture_priv(vdev);
908 struct v4l2_subdev *sd = priv->src_sd;
909 struct v4l2_device *v4l2_dev = sd->v4l2_dev;
910 struct video_device *vfd = vdev->vfd;
913 /* get media device */
914 priv->md = container_of(v4l2_dev->mdev, struct imx_media_dev, md);
916 vfd->v4l2_dev = v4l2_dev;
918 /* Initialize the default format and compose rectangle. */
919 ret = capture_init_format(priv);
923 /* Register the video device. */
924 ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1);
926 dev_err(priv->dev, "Failed to register video device\n");
930 dev_info(priv->dev, "Registered %s as /dev/%s\n", vfd->name,
931 video_device_node_name(vfd));
933 /* Create the link from the src_sd devnode pad to device node. */
934 if (link_flags & MEDIA_LNK_FL_IMMUTABLE)
935 link_flags |= MEDIA_LNK_FL_ENABLED;
936 ret = media_create_pad_link(&sd->entity, priv->src_sd_pad,
937 &vfd->entity, 0, link_flags);
939 dev_err(priv->dev, "failed to create link to device node\n");
940 video_unregister_device(vfd);
944 /* Add vdev to the video devices list. */
945 imx_media_add_video_device(priv->md, vdev);
949 EXPORT_SYMBOL_GPL(imx_media_capture_device_register);
951 void imx_media_capture_device_unregister(struct imx_media_video_dev *vdev)
953 struct capture_priv *priv = to_capture_priv(vdev);
954 struct video_device *vfd = priv->vdev.vfd;
956 media_entity_cleanup(&vfd->entity);
957 video_unregister_device(vfd);
959 EXPORT_SYMBOL_GPL(imx_media_capture_device_unregister);
961 struct imx_media_video_dev *
962 imx_media_capture_device_init(struct device *dev, struct v4l2_subdev *src_sd,
963 int pad, bool legacy_api)
965 struct capture_priv *priv;
966 struct video_device *vfd;
967 struct vb2_queue *vq;
970 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
972 return ERR_PTR(-ENOMEM);
974 priv->src_sd = src_sd;
975 priv->src_sd_pad = pad;
977 priv->legacy_api = legacy_api;
979 mutex_init(&priv->mutex);
980 INIT_LIST_HEAD(&priv->ready_q);
981 spin_lock_init(&priv->q_lock);
983 /* Allocate and initialize the video device. */
984 vfd = video_device_alloc();
986 return ERR_PTR(-ENOMEM);
988 vfd->fops = &capture_fops;
989 vfd->ioctl_ops = legacy_api ? &capture_legacy_ioctl_ops
990 : &capture_ioctl_ops;
992 vfd->release = video_device_release;
993 vfd->vfl_dir = VFL_DIR_RX;
994 vfd->tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
995 vfd->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING
996 | (!legacy_api ? V4L2_CAP_IO_MC : 0);
997 vfd->lock = &priv->mutex;
998 vfd->queue = &priv->q;
1000 snprintf(vfd->name, sizeof(vfd->name), "%s capture", src_sd->name);
1002 video_set_drvdata(vfd, priv);
1003 priv->vdev.vfd = vfd;
1004 INIT_LIST_HEAD(&priv->vdev.list);
1006 /* Initialize the video device pad. */
1007 priv->vdev_pad.flags = MEDIA_PAD_FL_SINK;
1008 ret = media_entity_pads_init(&vfd->entity, 1, &priv->vdev_pad);
1010 video_device_release(vfd);
1011 return ERR_PTR(ret);
1014 /* Initialize the vb2 queue. */
1016 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1017 vq->io_modes = VB2_MMAP | VB2_DMABUF;
1018 vq->drv_priv = priv;
1019 vq->buf_struct_size = sizeof(struct imx_media_buffer);
1020 vq->ops = &capture_qops;
1021 vq->mem_ops = &vb2_dma_contig_memops;
1022 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1023 vq->lock = &priv->mutex;
1024 vq->min_buffers_needed = 2;
1025 vq->dev = priv->dev;
1027 ret = vb2_queue_init(vq);
1029 dev_err(priv->dev, "vb2_queue_init failed\n");
1030 video_device_release(vfd);
1031 return ERR_PTR(ret);
1035 /* Initialize the control handler. */
1036 v4l2_ctrl_handler_init(&priv->ctrl_hdlr, 0);
1037 vfd->ctrl_handler = &priv->ctrl_hdlr;
1042 EXPORT_SYMBOL_GPL(imx_media_capture_device_init);
1044 void imx_media_capture_device_remove(struct imx_media_video_dev *vdev)
1046 struct capture_priv *priv = to_capture_priv(vdev);
1048 v4l2_ctrl_handler_free(&priv->ctrl_hdlr);
1050 EXPORT_SYMBOL_GPL(imx_media_capture_device_remove);
1052 MODULE_DESCRIPTION("i.MX5/6 v4l2 video capture interface driver");
1053 MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");
1054 MODULE_LICENSE("GPL");