2 * Video Capture Subdev for Freescale i.MX5/6 SOC
4 * Copyright (c) 2012-2016 Mentor Graphics Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 #include <linux/delay.h>
13 #include <linux/module.h>
14 #include <linux/of_platform.h>
15 #include <linux/pinctrl/consumer.h>
16 #include <linux/platform_device.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/timer.h>
21 #include <media/v4l2-ctrls.h>
22 #include <media/v4l2-device.h>
23 #include <media/v4l2-event.h>
24 #include <media/v4l2-fwnode.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/v4l2-mc.h>
27 #include <media/v4l2-subdev.h>
28 #include <media/videobuf2-dma-contig.h>
29 #include <video/imx-ipu-v3.h>
30 #include <media/imx.h>
31 #include "imx-media.h"
34 struct imx_media_video_dev vdev;
36 struct v4l2_subdev *src_sd;
40 struct imx_media_dev *md;
42 struct media_pad vdev_pad;
44 struct mutex mutex; /* capture device mutex */
46 /* the videobuf2 queue */
48 /* list of ready imx_media_buffer's from q */
49 struct list_head ready_q;
53 /* controls inherited from subdevs */
54 struct v4l2_ctrl_handler ctrl_hdlr;
57 bool stop; /* streaming is stopping */
60 #define to_capture_priv(v) container_of(v, struct capture_priv, vdev)
62 /* In bytes, per queue */
63 #define VID_MEM_LIMIT SZ_64M
65 static const struct vb2_ops capture_qops;
71 static int vidioc_querycap(struct file *file, void *fh,
72 struct v4l2_capability *cap)
74 struct capture_priv *priv = video_drvdata(file);
76 strlcpy(cap->driver, "imx-media-capture", sizeof(cap->driver));
77 strlcpy(cap->card, "imx-media-capture", sizeof(cap->card));
78 snprintf(cap->bus_info, sizeof(cap->bus_info),
79 "platform:%s", priv->src_sd->name);
84 static int capture_enum_framesizes(struct file *file, void *fh,
85 struct v4l2_frmsizeenum *fsize)
87 struct capture_priv *priv = video_drvdata(file);
88 const struct imx_media_pixfmt *cc;
89 struct v4l2_subdev_frame_size_enum fse = {
90 .index = fsize->index,
91 .pad = priv->src_sd_pad,
92 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
96 cc = imx_media_find_format(fsize->pixel_format, CS_SEL_ANY, true);
100 fse.code = cc->codes[0];
102 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_size, NULL, &fse);
106 if (fse.min_width == fse.max_width &&
107 fse.min_height == fse.max_height) {
108 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
109 fsize->discrete.width = fse.min_width;
110 fsize->discrete.height = fse.min_height;
112 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
113 fsize->stepwise.min_width = fse.min_width;
114 fsize->stepwise.max_width = fse.max_width;
115 fsize->stepwise.min_height = fse.min_height;
116 fsize->stepwise.max_height = fse.max_height;
117 fsize->stepwise.step_width = 1;
118 fsize->stepwise.step_height = 1;
124 static int capture_enum_frameintervals(struct file *file, void *fh,
125 struct v4l2_frmivalenum *fival)
127 struct capture_priv *priv = video_drvdata(file);
128 const struct imx_media_pixfmt *cc;
129 struct v4l2_subdev_frame_interval_enum fie = {
130 .index = fival->index,
131 .pad = priv->src_sd_pad,
132 .width = fival->width,
133 .height = fival->height,
134 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
138 cc = imx_media_find_format(fival->pixel_format, CS_SEL_ANY, true);
142 fie.code = cc->codes[0];
144 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_interval,
149 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
150 fival->discrete = fie.interval;
155 static int capture_enum_fmt_vid_cap(struct file *file, void *fh,
156 struct v4l2_fmtdesc *f)
158 struct capture_priv *priv = video_drvdata(file);
159 const struct imx_media_pixfmt *cc_src;
160 struct v4l2_subdev_format fmt_src;
164 fmt_src.pad = priv->src_sd_pad;
165 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
166 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
168 v4l2_err(priv->src_sd, "failed to get src_sd format\n");
172 cc_src = imx_media_find_ipu_format(fmt_src.format.code, CS_SEL_ANY);
174 u32 cs_sel = (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
175 CS_SEL_YUV : CS_SEL_RGB;
177 ret = imx_media_enum_format(&fourcc, f->index, cs_sel);
181 cc_src = imx_media_find_mbus_format(fmt_src.format.code,
183 if (WARN_ON(!cc_src))
188 fourcc = cc_src->fourcc;
191 f->pixelformat = fourcc;
196 static int capture_g_fmt_vid_cap(struct file *file, void *fh,
197 struct v4l2_format *f)
199 struct capture_priv *priv = video_drvdata(file);
206 static int capture_try_fmt_vid_cap(struct file *file, void *fh,
207 struct v4l2_format *f)
209 struct capture_priv *priv = video_drvdata(file);
210 struct v4l2_subdev_format fmt_src;
211 const struct imx_media_pixfmt *cc, *cc_src;
214 fmt_src.pad = priv->src_sd_pad;
215 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
216 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
220 cc_src = imx_media_find_ipu_format(fmt_src.format.code, CS_SEL_ANY);
224 cs_sel = (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
225 CS_SEL_YUV : CS_SEL_RGB;
226 fourcc = f->fmt.pix.pixelformat;
228 cc = imx_media_find_format(fourcc, cs_sel, false);
230 imx_media_enum_format(&fourcc, 0, cs_sel);
231 cc = imx_media_find_format(fourcc, cs_sel, false);
234 cc_src = imx_media_find_mbus_format(fmt_src.format.code,
236 if (WARN_ON(!cc_src))
242 imx_media_mbus_fmt_to_pix_fmt(&f->fmt.pix, &fmt_src.format, cc);
247 static int capture_s_fmt_vid_cap(struct file *file, void *fh,
248 struct v4l2_format *f)
250 struct capture_priv *priv = video_drvdata(file);
253 if (vb2_is_busy(&priv->q)) {
254 v4l2_err(priv->src_sd, "%s queue busy\n", __func__);
258 ret = capture_try_fmt_vid_cap(file, priv, f);
262 priv->vdev.fmt.fmt.pix = f->fmt.pix;
263 priv->vdev.cc = imx_media_find_format(f->fmt.pix.pixelformat,
269 static int capture_querystd(struct file *file, void *fh, v4l2_std_id *std)
271 struct capture_priv *priv = video_drvdata(file);
273 return v4l2_subdev_call(priv->src_sd, video, querystd, std);
276 static int capture_g_std(struct file *file, void *fh, v4l2_std_id *std)
278 struct capture_priv *priv = video_drvdata(file);
280 return v4l2_subdev_call(priv->src_sd, video, g_std, std);
283 static int capture_s_std(struct file *file, void *fh, v4l2_std_id std)
285 struct capture_priv *priv = video_drvdata(file);
287 if (vb2_is_busy(&priv->q))
290 return v4l2_subdev_call(priv->src_sd, video, s_std, std);
293 static int capture_g_parm(struct file *file, void *fh,
294 struct v4l2_streamparm *a)
296 struct capture_priv *priv = video_drvdata(file);
297 struct v4l2_subdev_frame_interval fi;
300 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
303 memset(&fi, 0, sizeof(fi));
304 fi.pad = priv->src_sd_pad;
305 ret = v4l2_subdev_call(priv->src_sd, video, g_frame_interval, &fi);
309 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
310 a->parm.capture.timeperframe = fi.interval;
315 static int capture_s_parm(struct file *file, void *fh,
316 struct v4l2_streamparm *a)
318 struct capture_priv *priv = video_drvdata(file);
319 struct v4l2_subdev_frame_interval fi;
322 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
325 memset(&fi, 0, sizeof(fi));
326 fi.pad = priv->src_sd_pad;
327 fi.interval = a->parm.capture.timeperframe;
328 ret = v4l2_subdev_call(priv->src_sd, video, s_frame_interval, &fi);
332 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
333 a->parm.capture.timeperframe = fi.interval;
338 static const struct v4l2_ioctl_ops capture_ioctl_ops = {
339 .vidioc_querycap = vidioc_querycap,
341 .vidioc_enum_framesizes = capture_enum_framesizes,
342 .vidioc_enum_frameintervals = capture_enum_frameintervals,
344 .vidioc_enum_fmt_vid_cap = capture_enum_fmt_vid_cap,
345 .vidioc_g_fmt_vid_cap = capture_g_fmt_vid_cap,
346 .vidioc_try_fmt_vid_cap = capture_try_fmt_vid_cap,
347 .vidioc_s_fmt_vid_cap = capture_s_fmt_vid_cap,
349 .vidioc_querystd = capture_querystd,
350 .vidioc_g_std = capture_g_std,
351 .vidioc_s_std = capture_s_std,
353 .vidioc_g_parm = capture_g_parm,
354 .vidioc_s_parm = capture_s_parm,
356 .vidioc_reqbufs = vb2_ioctl_reqbufs,
357 .vidioc_create_bufs = vb2_ioctl_create_bufs,
358 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
359 .vidioc_querybuf = vb2_ioctl_querybuf,
360 .vidioc_qbuf = vb2_ioctl_qbuf,
361 .vidioc_dqbuf = vb2_ioctl_dqbuf,
362 .vidioc_expbuf = vb2_ioctl_expbuf,
363 .vidioc_streamon = vb2_ioctl_streamon,
364 .vidioc_streamoff = vb2_ioctl_streamoff,
371 static int capture_queue_setup(struct vb2_queue *vq,
372 unsigned int *nbuffers,
373 unsigned int *nplanes,
374 unsigned int sizes[],
375 struct device *alloc_devs[])
377 struct capture_priv *priv = vb2_get_drv_priv(vq);
378 struct v4l2_pix_format *pix = &priv->vdev.fmt.fmt.pix;
379 unsigned int count = *nbuffers;
381 if (vq->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
385 if (*nplanes != 1 || sizes[0] < pix->sizeimage)
387 count += vq->num_buffers;
390 count = min_t(__u32, VID_MEM_LIMIT / pix->sizeimage, count);
393 *nbuffers = (count < vq->num_buffers) ? 0 :
394 count - vq->num_buffers;
399 sizes[0] = pix->sizeimage;
404 static int capture_buf_init(struct vb2_buffer *vb)
406 struct imx_media_buffer *buf = to_imx_media_vb(vb);
408 INIT_LIST_HEAD(&buf->list);
413 static int capture_buf_prepare(struct vb2_buffer *vb)
415 struct vb2_queue *vq = vb->vb2_queue;
416 struct capture_priv *priv = vb2_get_drv_priv(vq);
417 struct v4l2_pix_format *pix = &priv->vdev.fmt.fmt.pix;
419 if (vb2_plane_size(vb, 0) < pix->sizeimage) {
420 v4l2_err(priv->src_sd,
421 "data will not fit into plane (%lu < %lu)\n",
422 vb2_plane_size(vb, 0), (long)pix->sizeimage);
426 vb2_set_plane_payload(vb, 0, pix->sizeimage);
431 static void capture_buf_queue(struct vb2_buffer *vb)
433 struct capture_priv *priv = vb2_get_drv_priv(vb->vb2_queue);
434 struct imx_media_buffer *buf = to_imx_media_vb(vb);
437 spin_lock_irqsave(&priv->q_lock, flags);
439 list_add_tail(&buf->list, &priv->ready_q);
441 spin_unlock_irqrestore(&priv->q_lock, flags);
444 static int capture_start_streaming(struct vb2_queue *vq, unsigned int count)
446 struct capture_priv *priv = vb2_get_drv_priv(vq);
447 struct imx_media_buffer *buf, *tmp;
451 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
454 v4l2_err(priv->src_sd, "pipeline start failed with %d\n", ret);
463 spin_lock_irqsave(&priv->q_lock, flags);
464 list_for_each_entry_safe(buf, tmp, &priv->ready_q, list) {
465 list_del(&buf->list);
466 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_QUEUED);
468 spin_unlock_irqrestore(&priv->q_lock, flags);
472 static void capture_stop_streaming(struct vb2_queue *vq)
474 struct capture_priv *priv = vb2_get_drv_priv(vq);
475 struct imx_media_buffer *frame;
479 spin_lock_irqsave(&priv->q_lock, flags);
481 spin_unlock_irqrestore(&priv->q_lock, flags);
483 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
486 v4l2_warn(priv->src_sd, "pipeline stop failed with %d\n", ret);
488 /* release all active buffers */
489 spin_lock_irqsave(&priv->q_lock, flags);
490 while (!list_empty(&priv->ready_q)) {
491 frame = list_entry(priv->ready_q.next,
492 struct imx_media_buffer, list);
493 list_del(&frame->list);
494 vb2_buffer_done(&frame->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
496 spin_unlock_irqrestore(&priv->q_lock, flags);
499 static const struct vb2_ops capture_qops = {
500 .queue_setup = capture_queue_setup,
501 .buf_init = capture_buf_init,
502 .buf_prepare = capture_buf_prepare,
503 .buf_queue = capture_buf_queue,
504 .wait_prepare = vb2_ops_wait_prepare,
505 .wait_finish = vb2_ops_wait_finish,
506 .start_streaming = capture_start_streaming,
507 .stop_streaming = capture_stop_streaming,
513 static int capture_open(struct file *file)
515 struct capture_priv *priv = video_drvdata(file);
516 struct video_device *vfd = priv->vdev.vfd;
519 if (mutex_lock_interruptible(&priv->mutex))
522 ret = v4l2_fh_open(file);
524 v4l2_err(priv->src_sd, "v4l2_fh_open failed\n");
526 ret = v4l2_pipeline_pm_use(&vfd->entity, 1);
528 v4l2_fh_release(file);
530 mutex_unlock(&priv->mutex);
534 static int capture_release(struct file *file)
536 struct capture_priv *priv = video_drvdata(file);
537 struct video_device *vfd = priv->vdev.vfd;
538 struct vb2_queue *vq = &priv->q;
541 mutex_lock(&priv->mutex);
543 if (file->private_data == vq->owner) {
544 vb2_queue_release(vq);
548 v4l2_pipeline_pm_use(&vfd->entity, 0);
550 v4l2_fh_release(file);
551 mutex_unlock(&priv->mutex);
555 static const struct v4l2_file_operations capture_fops = {
556 .owner = THIS_MODULE,
557 .open = capture_open,
558 .release = capture_release,
559 .poll = vb2_fop_poll,
560 .unlocked_ioctl = video_ioctl2,
561 .mmap = vb2_fop_mmap,
564 static struct video_device capture_videodev = {
565 .fops = &capture_fops,
566 .ioctl_ops = &capture_ioctl_ops,
568 .release = video_device_release,
569 .vfl_dir = VFL_DIR_RX,
570 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
571 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
574 void imx_media_capture_device_set_format(struct imx_media_video_dev *vdev,
575 struct v4l2_pix_format *pix)
577 struct capture_priv *priv = to_capture_priv(vdev);
579 mutex_lock(&priv->mutex);
580 priv->vdev.fmt.fmt.pix = *pix;
581 priv->vdev.cc = imx_media_find_format(pix->pixelformat, CS_SEL_ANY,
583 mutex_unlock(&priv->mutex);
585 EXPORT_SYMBOL_GPL(imx_media_capture_device_set_format);
587 struct imx_media_buffer *
588 imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev)
590 struct capture_priv *priv = to_capture_priv(vdev);
591 struct imx_media_buffer *buf = NULL;
594 spin_lock_irqsave(&priv->q_lock, flags);
596 /* get next queued buffer */
597 if (!list_empty(&priv->ready_q)) {
598 buf = list_entry(priv->ready_q.next, struct imx_media_buffer,
600 list_del(&buf->list);
603 spin_unlock_irqrestore(&priv->q_lock, flags);
607 EXPORT_SYMBOL_GPL(imx_media_capture_device_next_buf);
609 void imx_media_capture_device_error(struct imx_media_video_dev *vdev)
611 struct capture_priv *priv = to_capture_priv(vdev);
612 struct vb2_queue *vq = &priv->q;
615 if (!vb2_is_streaming(vq))
618 spin_lock_irqsave(&priv->q_lock, flags);
620 spin_unlock_irqrestore(&priv->q_lock, flags);
622 EXPORT_SYMBOL_GPL(imx_media_capture_device_error);
624 int imx_media_capture_device_register(struct imx_media_video_dev *vdev)
626 struct capture_priv *priv = to_capture_priv(vdev);
627 struct v4l2_subdev *sd = priv->src_sd;
628 struct video_device *vfd = vdev->vfd;
629 struct vb2_queue *vq = &priv->q;
630 struct v4l2_subdev_format fmt_src;
633 /* get media device */
634 priv->md = dev_get_drvdata(sd->v4l2_dev->dev);
636 vfd->v4l2_dev = sd->v4l2_dev;
638 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
640 v4l2_err(sd, "Failed to register video device\n");
644 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
645 vq->io_modes = VB2_MMAP | VB2_DMABUF;
647 vq->buf_struct_size = sizeof(struct imx_media_buffer);
648 vq->ops = &capture_qops;
649 vq->mem_ops = &vb2_dma_contig_memops;
650 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
651 vq->lock = &priv->mutex;
652 vq->min_buffers_needed = 2;
655 ret = vb2_queue_init(vq);
657 v4l2_err(sd, "vb2_queue_init failed\n");
661 INIT_LIST_HEAD(&priv->ready_q);
663 priv->vdev_pad.flags = MEDIA_PAD_FL_SINK;
664 ret = media_entity_pads_init(&vfd->entity, 1, &priv->vdev_pad);
666 v4l2_err(sd, "failed to init dev pad\n");
670 /* create the link from the src_sd devnode pad to device node */
671 ret = media_create_pad_link(&sd->entity, priv->src_sd_pad,
674 v4l2_err(sd, "failed to create link to device node\n");
678 /* setup default format */
679 fmt_src.pad = priv->src_sd_pad;
680 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
681 ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt_src);
683 v4l2_err(sd, "failed to get src_sd format\n");
687 vdev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
688 imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt.fmt.pix,
689 &fmt_src.format, NULL);
690 vdev->cc = imx_media_find_format(vdev->fmt.fmt.pix.pixelformat,
693 v4l2_info(sd, "Registered %s as /dev/%s\n", vfd->name,
694 video_device_node_name(vfd));
696 vfd->ctrl_handler = &priv->ctrl_hdlr;
700 video_unregister_device(vfd);
703 EXPORT_SYMBOL_GPL(imx_media_capture_device_register);
705 void imx_media_capture_device_unregister(struct imx_media_video_dev *vdev)
707 struct capture_priv *priv = to_capture_priv(vdev);
708 struct video_device *vfd = priv->vdev.vfd;
710 mutex_lock(&priv->mutex);
712 if (video_is_registered(vfd)) {
713 video_unregister_device(vfd);
714 media_entity_cleanup(&vfd->entity);
717 mutex_unlock(&priv->mutex);
719 EXPORT_SYMBOL_GPL(imx_media_capture_device_unregister);
721 struct imx_media_video_dev *
722 imx_media_capture_device_init(struct v4l2_subdev *src_sd, int pad)
724 struct capture_priv *priv;
725 struct video_device *vfd;
727 priv = devm_kzalloc(src_sd->dev, sizeof(*priv), GFP_KERNEL);
729 return ERR_PTR(-ENOMEM);
731 priv->src_sd = src_sd;
732 priv->src_sd_pad = pad;
733 priv->dev = src_sd->dev;
735 mutex_init(&priv->mutex);
736 spin_lock_init(&priv->q_lock);
738 snprintf(capture_videodev.name, sizeof(capture_videodev.name),
739 "%s capture", src_sd->name);
741 vfd = video_device_alloc();
743 return ERR_PTR(-ENOMEM);
745 *vfd = capture_videodev;
746 vfd->lock = &priv->mutex;
747 vfd->queue = &priv->q;
748 priv->vdev.vfd = vfd;
750 INIT_LIST_HEAD(&priv->vdev.list);
752 video_set_drvdata(vfd, priv);
754 v4l2_ctrl_handler_init(&priv->ctrl_hdlr, 0);
758 EXPORT_SYMBOL_GPL(imx_media_capture_device_init);
760 void imx_media_capture_device_remove(struct imx_media_video_dev *vdev)
762 struct capture_priv *priv = to_capture_priv(vdev);
764 v4l2_ctrl_handler_free(&priv->ctrl_hdlr);
766 EXPORT_SYMBOL_GPL(imx_media_capture_device_remove);
768 MODULE_DESCRIPTION("i.MX5/6 v4l2 video capture interface driver");
769 MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");
770 MODULE_LICENSE("GPL");