1
2
3
4
5
6
7#include <linux/delay.h>
8#include <linux/fs.h>
9#include <linux/module.h>
10#include <linux/of_platform.h>
11#include <linux/pinctrl/consumer.h>
12#include <linux/platform_device.h>
13#include <linux/sched.h>
14#include <linux/slab.h>
15#include <linux/spinlock.h>
16#include <linux/timer.h>
17#include <media/v4l2-ctrls.h>
18#include <media/v4l2-device.h>
19#include <media/v4l2-event.h>
20#include <media/v4l2-fwnode.h>
21#include <media/v4l2-ioctl.h>
22#include <media/v4l2-mc.h>
23#include <media/v4l2-subdev.h>
24#include <media/videobuf2-dma-contig.h>
25#include <video/imx-ipu-v3.h>
26#include <media/imx.h>
27#include "imx-media.h"
28
29struct capture_priv {
30 struct imx_media_video_dev vdev;
31
32 struct v4l2_subdev *src_sd;
33 int src_sd_pad;
34 struct device *dev;
35
36 struct imx_media_dev *md;
37
38 struct media_pad vdev_pad;
39
40 struct mutex mutex;
41
42
43 struct vb2_queue q;
44
45 struct list_head ready_q;
46
47 spinlock_t q_lock;
48
49
50 struct v4l2_ctrl_handler ctrl_hdlr;
51
52
53 bool stop;
54};
55
56#define to_capture_priv(v) container_of(v, struct capture_priv, vdev)
57
58
59#define VID_MEM_LIMIT SZ_64M
60
61static const struct vb2_ops capture_qops;
62
63
64
65
66
67static int vidioc_querycap(struct file *file, void *fh,
68 struct v4l2_capability *cap)
69{
70 struct capture_priv *priv = video_drvdata(file);
71
72 strscpy(cap->driver, "imx-media-capture", sizeof(cap->driver));
73 strscpy(cap->card, "imx-media-capture", sizeof(cap->card));
74 snprintf(cap->bus_info, sizeof(cap->bus_info),
75 "platform:%s", priv->src_sd->name);
76
77 return 0;
78}
79
80static int capture_enum_framesizes(struct file *file, void *fh,
81 struct v4l2_frmsizeenum *fsize)
82{
83 struct capture_priv *priv = video_drvdata(file);
84 const struct imx_media_pixfmt *cc;
85 struct v4l2_subdev_frame_size_enum fse = {
86 .index = fsize->index,
87 .pad = priv->src_sd_pad,
88 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
89 };
90 int ret;
91
92 cc = imx_media_find_format(fsize->pixel_format, CS_SEL_ANY, true);
93 if (!cc)
94 return -EINVAL;
95
96 fse.code = cc->codes[0];
97
98 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_size, NULL, &fse);
99 if (ret)
100 return ret;
101
102 if (fse.min_width == fse.max_width &&
103 fse.min_height == fse.max_height) {
104 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
105 fsize->discrete.width = fse.min_width;
106 fsize->discrete.height = fse.min_height;
107 } else {
108 fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
109 fsize->stepwise.min_width = fse.min_width;
110 fsize->stepwise.max_width = fse.max_width;
111 fsize->stepwise.min_height = fse.min_height;
112 fsize->stepwise.max_height = fse.max_height;
113 fsize->stepwise.step_width = 1;
114 fsize->stepwise.step_height = 1;
115 }
116
117 return 0;
118}
119
120static int capture_enum_frameintervals(struct file *file, void *fh,
121 struct v4l2_frmivalenum *fival)
122{
123 struct capture_priv *priv = video_drvdata(file);
124 const struct imx_media_pixfmt *cc;
125 struct v4l2_subdev_frame_interval_enum fie = {
126 .index = fival->index,
127 .pad = priv->src_sd_pad,
128 .width = fival->width,
129 .height = fival->height,
130 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
131 };
132 int ret;
133
134 cc = imx_media_find_format(fival->pixel_format, CS_SEL_ANY, true);
135 if (!cc)
136 return -EINVAL;
137
138 fie.code = cc->codes[0];
139
140 ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_interval,
141 NULL, &fie);
142 if (ret)
143 return ret;
144
145 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
146 fival->discrete = fie.interval;
147
148 return 0;
149}
150
151static int capture_enum_fmt_vid_cap(struct file *file, void *fh,
152 struct v4l2_fmtdesc *f)
153{
154 struct capture_priv *priv = video_drvdata(file);
155 const struct imx_media_pixfmt *cc_src;
156 struct v4l2_subdev_format fmt_src;
157 u32 fourcc;
158 int ret;
159
160 fmt_src.pad = priv->src_sd_pad;
161 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
162 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
163 if (ret) {
164 v4l2_err(priv->src_sd, "failed to get src_sd format\n");
165 return ret;
166 }
167
168 cc_src = imx_media_find_ipu_format(fmt_src.format.code, CS_SEL_ANY);
169 if (cc_src) {
170 u32 cs_sel = (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
171 CS_SEL_YUV : CS_SEL_RGB;
172
173 ret = imx_media_enum_format(&fourcc, f->index, cs_sel);
174 if (ret)
175 return ret;
176 } else {
177 cc_src = imx_media_find_mbus_format(fmt_src.format.code,
178 CS_SEL_ANY, true);
179 if (WARN_ON(!cc_src))
180 return -EINVAL;
181
182 if (f->index != 0)
183 return -EINVAL;
184 fourcc = cc_src->fourcc;
185 }
186
187 f->pixelformat = fourcc;
188
189 return 0;
190}
191
192static int capture_g_fmt_vid_cap(struct file *file, void *fh,
193 struct v4l2_format *f)
194{
195 struct capture_priv *priv = video_drvdata(file);
196
197 *f = priv->vdev.fmt;
198
199 return 0;
200}
201
202static int __capture_try_fmt_vid_cap(struct capture_priv *priv,
203 struct v4l2_subdev_format *fmt_src,
204 struct v4l2_format *f,
205 const struct imx_media_pixfmt **retcc,
206 struct v4l2_rect *compose)
207{
208 const struct imx_media_pixfmt *cc, *cc_src;
209
210 cc_src = imx_media_find_ipu_format(fmt_src->format.code, CS_SEL_ANY);
211 if (cc_src) {
212 u32 fourcc, cs_sel;
213
214 cs_sel = (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
215 CS_SEL_YUV : CS_SEL_RGB;
216 fourcc = f->fmt.pix.pixelformat;
217
218 cc = imx_media_find_format(fourcc, cs_sel, false);
219 if (!cc) {
220 imx_media_enum_format(&fourcc, 0, cs_sel);
221 cc = imx_media_find_format(fourcc, cs_sel, false);
222 }
223 } else {
224 cc_src = imx_media_find_mbus_format(fmt_src->format.code,
225 CS_SEL_ANY, true);
226 if (WARN_ON(!cc_src))
227 return -EINVAL;
228
229 cc = cc_src;
230 }
231
232
233 if (V4L2_FIELD_IS_INTERLACED(f->fmt.pix.field)) {
234 switch (fmt_src->format.field) {
235 case V4L2_FIELD_SEQ_TB:
236 fmt_src->format.field = V4L2_FIELD_INTERLACED_TB;
237 break;
238 case V4L2_FIELD_SEQ_BT:
239 fmt_src->format.field = V4L2_FIELD_INTERLACED_BT;
240 break;
241 default:
242 break;
243 }
244 }
245
246 imx_media_mbus_fmt_to_pix_fmt(&f->fmt.pix, &fmt_src->format, cc);
247
248 if (retcc)
249 *retcc = cc;
250
251 if (compose) {
252 compose->left = 0;
253 compose->top = 0;
254 compose->width = fmt_src->format.width;
255 compose->height = fmt_src->format.height;
256 }
257
258 return 0;
259}
260
261static int capture_try_fmt_vid_cap(struct file *file, void *fh,
262 struct v4l2_format *f)
263{
264 struct capture_priv *priv = video_drvdata(file);
265 struct v4l2_subdev_format fmt_src;
266 int ret;
267
268 fmt_src.pad = priv->src_sd_pad;
269 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
270 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
271 if (ret)
272 return ret;
273
274 return __capture_try_fmt_vid_cap(priv, &fmt_src, f, NULL, NULL);
275}
276
277static int capture_s_fmt_vid_cap(struct file *file, void *fh,
278 struct v4l2_format *f)
279{
280 struct capture_priv *priv = video_drvdata(file);
281 struct v4l2_subdev_format fmt_src;
282 int ret;
283
284 if (vb2_is_busy(&priv->q)) {
285 v4l2_err(priv->src_sd, "%s queue busy\n", __func__);
286 return -EBUSY;
287 }
288
289 fmt_src.pad = priv->src_sd_pad;
290 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
291 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
292 if (ret)
293 return ret;
294
295 ret = __capture_try_fmt_vid_cap(priv, &fmt_src, f, &priv->vdev.cc,
296 &priv->vdev.compose);
297 if (ret)
298 return ret;
299
300 priv->vdev.fmt.fmt.pix = f->fmt.pix;
301
302 return 0;
303}
304
305static int capture_querystd(struct file *file, void *fh, v4l2_std_id *std)
306{
307 struct capture_priv *priv = video_drvdata(file);
308
309 return v4l2_subdev_call(priv->src_sd, video, querystd, std);
310}
311
312static int capture_g_std(struct file *file, void *fh, v4l2_std_id *std)
313{
314 struct capture_priv *priv = video_drvdata(file);
315
316 return v4l2_subdev_call(priv->src_sd, video, g_std, std);
317}
318
319static int capture_s_std(struct file *file, void *fh, v4l2_std_id std)
320{
321 struct capture_priv *priv = video_drvdata(file);
322
323 if (vb2_is_busy(&priv->q))
324 return -EBUSY;
325
326 return v4l2_subdev_call(priv->src_sd, video, s_std, std);
327}
328
329static int capture_g_selection(struct file *file, void *fh,
330 struct v4l2_selection *s)
331{
332 struct capture_priv *priv = video_drvdata(file);
333
334 switch (s->target) {
335 case V4L2_SEL_TGT_COMPOSE:
336 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
337 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
338
339 s->r = priv->vdev.compose;
340 break;
341 case V4L2_SEL_TGT_COMPOSE_PADDED:
342
343
344
345
346
347 s->r.left = 0;
348 s->r.top = 0;
349 s->r.width = priv->vdev.fmt.fmt.pix.width;
350 s->r.height = priv->vdev.fmt.fmt.pix.height;
351 break;
352 default:
353 return -EINVAL;
354 }
355
356 return 0;
357}
358
359static int capture_g_parm(struct file *file, void *fh,
360 struct v4l2_streamparm *a)
361{
362 struct capture_priv *priv = video_drvdata(file);
363 struct v4l2_subdev_frame_interval fi;
364 int ret;
365
366 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
367 return -EINVAL;
368
369 memset(&fi, 0, sizeof(fi));
370 fi.pad = priv->src_sd_pad;
371 ret = v4l2_subdev_call(priv->src_sd, video, g_frame_interval, &fi);
372 if (ret < 0)
373 return ret;
374
375 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
376 a->parm.capture.timeperframe = fi.interval;
377
378 return 0;
379}
380
381static int capture_s_parm(struct file *file, void *fh,
382 struct v4l2_streamparm *a)
383{
384 struct capture_priv *priv = video_drvdata(file);
385 struct v4l2_subdev_frame_interval fi;
386 int ret;
387
388 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
389 return -EINVAL;
390
391 memset(&fi, 0, sizeof(fi));
392 fi.pad = priv->src_sd_pad;
393 fi.interval = a->parm.capture.timeperframe;
394 ret = v4l2_subdev_call(priv->src_sd, video, s_frame_interval, &fi);
395 if (ret < 0)
396 return ret;
397
398 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
399 a->parm.capture.timeperframe = fi.interval;
400
401 return 0;
402}
403
404static int capture_subscribe_event(struct v4l2_fh *fh,
405 const struct v4l2_event_subscription *sub)
406{
407 switch (sub->type) {
408 case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
409 return v4l2_event_subscribe(fh, sub, 0, NULL);
410 case V4L2_EVENT_SOURCE_CHANGE:
411 return v4l2_src_change_event_subscribe(fh, sub);
412 case V4L2_EVENT_CTRL:
413 return v4l2_ctrl_subscribe_event(fh, sub);
414 default:
415 return -EINVAL;
416 }
417}
418
419static const struct v4l2_ioctl_ops capture_ioctl_ops = {
420 .vidioc_querycap = vidioc_querycap,
421
422 .vidioc_enum_framesizes = capture_enum_framesizes,
423 .vidioc_enum_frameintervals = capture_enum_frameintervals,
424
425 .vidioc_enum_fmt_vid_cap = capture_enum_fmt_vid_cap,
426 .vidioc_g_fmt_vid_cap = capture_g_fmt_vid_cap,
427 .vidioc_try_fmt_vid_cap = capture_try_fmt_vid_cap,
428 .vidioc_s_fmt_vid_cap = capture_s_fmt_vid_cap,
429
430 .vidioc_querystd = capture_querystd,
431 .vidioc_g_std = capture_g_std,
432 .vidioc_s_std = capture_s_std,
433
434 .vidioc_g_selection = capture_g_selection,
435
436 .vidioc_g_parm = capture_g_parm,
437 .vidioc_s_parm = capture_s_parm,
438
439 .vidioc_reqbufs = vb2_ioctl_reqbufs,
440 .vidioc_create_bufs = vb2_ioctl_create_bufs,
441 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
442 .vidioc_querybuf = vb2_ioctl_querybuf,
443 .vidioc_qbuf = vb2_ioctl_qbuf,
444 .vidioc_dqbuf = vb2_ioctl_dqbuf,
445 .vidioc_expbuf = vb2_ioctl_expbuf,
446 .vidioc_streamon = vb2_ioctl_streamon,
447 .vidioc_streamoff = vb2_ioctl_streamoff,
448
449 .vidioc_subscribe_event = capture_subscribe_event,
450 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
451};
452
453
454
455
456
457static int capture_queue_setup(struct vb2_queue *vq,
458 unsigned int *nbuffers,
459 unsigned int *nplanes,
460 unsigned int sizes[],
461 struct device *alloc_devs[])
462{
463 struct capture_priv *priv = vb2_get_drv_priv(vq);
464 struct v4l2_pix_format *pix = &priv->vdev.fmt.fmt.pix;
465 unsigned int count = *nbuffers;
466
467 if (vq->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
468 return -EINVAL;
469
470 if (*nplanes) {
471 if (*nplanes != 1 || sizes[0] < pix->sizeimage)
472 return -EINVAL;
473 count += vq->num_buffers;
474 }
475
476 count = min_t(__u32, VID_MEM_LIMIT / pix->sizeimage, count);
477
478 if (*nplanes)
479 *nbuffers = (count < vq->num_buffers) ? 0 :
480 count - vq->num_buffers;
481 else
482 *nbuffers = count;
483
484 *nplanes = 1;
485 sizes[0] = pix->sizeimage;
486
487 return 0;
488}
489
490static int capture_buf_init(struct vb2_buffer *vb)
491{
492 struct imx_media_buffer *buf = to_imx_media_vb(vb);
493
494 INIT_LIST_HEAD(&buf->list);
495
496 return 0;
497}
498
499static int capture_buf_prepare(struct vb2_buffer *vb)
500{
501 struct vb2_queue *vq = vb->vb2_queue;
502 struct capture_priv *priv = vb2_get_drv_priv(vq);
503 struct v4l2_pix_format *pix = &priv->vdev.fmt.fmt.pix;
504
505 if (vb2_plane_size(vb, 0) < pix->sizeimage) {
506 v4l2_err(priv->src_sd,
507 "data will not fit into plane (%lu < %lu)\n",
508 vb2_plane_size(vb, 0), (long)pix->sizeimage);
509 return -EINVAL;
510 }
511
512 vb2_set_plane_payload(vb, 0, pix->sizeimage);
513
514 return 0;
515}
516
517static void capture_buf_queue(struct vb2_buffer *vb)
518{
519 struct capture_priv *priv = vb2_get_drv_priv(vb->vb2_queue);
520 struct imx_media_buffer *buf = to_imx_media_vb(vb);
521 unsigned long flags;
522
523 spin_lock_irqsave(&priv->q_lock, flags);
524
525 list_add_tail(&buf->list, &priv->ready_q);
526
527 spin_unlock_irqrestore(&priv->q_lock, flags);
528}
529
530static int capture_validate_fmt(struct capture_priv *priv)
531{
532 struct v4l2_subdev_format fmt_src;
533 const struct imx_media_pixfmt *cc;
534 struct v4l2_rect compose;
535 struct v4l2_format f;
536 int ret;
537
538 fmt_src.pad = priv->src_sd_pad;
539 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
540 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
541 if (ret)
542 return ret;
543
544 v4l2_fill_pix_format(&f.fmt.pix, &fmt_src.format);
545
546 ret = __capture_try_fmt_vid_cap(priv, &fmt_src, &f, &cc, &compose);
547 if (ret)
548 return ret;
549
550 return (priv->vdev.fmt.fmt.pix.width != f.fmt.pix.width ||
551 priv->vdev.fmt.fmt.pix.height != f.fmt.pix.height ||
552 priv->vdev.cc->cs != cc->cs ||
553 priv->vdev.compose.width != compose.width ||
554 priv->vdev.compose.height != compose.height) ? -EINVAL : 0;
555}
556
557static int capture_start_streaming(struct vb2_queue *vq, unsigned int count)
558{
559 struct capture_priv *priv = vb2_get_drv_priv(vq);
560 struct imx_media_buffer *buf, *tmp;
561 unsigned long flags;
562 int ret;
563
564 ret = capture_validate_fmt(priv);
565 if (ret) {
566 v4l2_err(priv->src_sd, "capture format not valid\n");
567 goto return_bufs;
568 }
569
570 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
571 true);
572 if (ret) {
573 v4l2_err(priv->src_sd, "pipeline start failed with %d\n", ret);
574 goto return_bufs;
575 }
576
577 priv->stop = false;
578
579 return 0;
580
581return_bufs:
582 spin_lock_irqsave(&priv->q_lock, flags);
583 list_for_each_entry_safe(buf, tmp, &priv->ready_q, list) {
584 list_del(&buf->list);
585 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_QUEUED);
586 }
587 spin_unlock_irqrestore(&priv->q_lock, flags);
588 return ret;
589}
590
591static void capture_stop_streaming(struct vb2_queue *vq)
592{
593 struct capture_priv *priv = vb2_get_drv_priv(vq);
594 struct imx_media_buffer *frame;
595 struct imx_media_buffer *tmp;
596 unsigned long flags;
597 int ret;
598
599 spin_lock_irqsave(&priv->q_lock, flags);
600 priv->stop = true;
601 spin_unlock_irqrestore(&priv->q_lock, flags);
602
603 ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
604 false);
605 if (ret)
606 v4l2_warn(priv->src_sd, "pipeline stop failed with %d\n", ret);
607
608
609 spin_lock_irqsave(&priv->q_lock, flags);
610 list_for_each_entry_safe(frame, tmp, &priv->ready_q, list) {
611 list_del(&frame->list);
612 vb2_buffer_done(&frame->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
613 }
614 spin_unlock_irqrestore(&priv->q_lock, flags);
615}
616
617static const struct vb2_ops capture_qops = {
618 .queue_setup = capture_queue_setup,
619 .buf_init = capture_buf_init,
620 .buf_prepare = capture_buf_prepare,
621 .buf_queue = capture_buf_queue,
622 .wait_prepare = vb2_ops_wait_prepare,
623 .wait_finish = vb2_ops_wait_finish,
624 .start_streaming = capture_start_streaming,
625 .stop_streaming = capture_stop_streaming,
626};
627
628
629
630
631static int capture_open(struct file *file)
632{
633 struct capture_priv *priv = video_drvdata(file);
634 struct video_device *vfd = priv->vdev.vfd;
635 int ret;
636
637 if (mutex_lock_interruptible(&priv->mutex))
638 return -ERESTARTSYS;
639
640 ret = v4l2_fh_open(file);
641 if (ret)
642 v4l2_err(priv->src_sd, "v4l2_fh_open failed\n");
643
644 ret = v4l2_pipeline_pm_use(&vfd->entity, 1);
645 if (ret)
646 v4l2_fh_release(file);
647
648 mutex_unlock(&priv->mutex);
649 return ret;
650}
651
652static int capture_release(struct file *file)
653{
654 struct capture_priv *priv = video_drvdata(file);
655 struct video_device *vfd = priv->vdev.vfd;
656 struct vb2_queue *vq = &priv->q;
657
658 mutex_lock(&priv->mutex);
659
660 if (file->private_data == vq->owner) {
661 vb2_queue_release(vq);
662 vq->owner = NULL;
663 }
664
665 v4l2_pipeline_pm_use(&vfd->entity, 0);
666
667 v4l2_fh_release(file);
668 mutex_unlock(&priv->mutex);
669 return 0;
670}
671
672static const struct v4l2_file_operations capture_fops = {
673 .owner = THIS_MODULE,
674 .open = capture_open,
675 .release = capture_release,
676 .poll = vb2_fop_poll,
677 .unlocked_ioctl = video_ioctl2,
678 .mmap = vb2_fop_mmap,
679};
680
681static struct video_device capture_videodev = {
682 .fops = &capture_fops,
683 .ioctl_ops = &capture_ioctl_ops,
684 .minor = -1,
685 .release = video_device_release,
686 .vfl_dir = VFL_DIR_RX,
687 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
688 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
689};
690
691struct imx_media_buffer *
692imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev)
693{
694 struct capture_priv *priv = to_capture_priv(vdev);
695 struct imx_media_buffer *buf = NULL;
696 unsigned long flags;
697
698 spin_lock_irqsave(&priv->q_lock, flags);
699
700
701 if (!list_empty(&priv->ready_q)) {
702 buf = list_entry(priv->ready_q.next, struct imx_media_buffer,
703 list);
704 list_del(&buf->list);
705 }
706
707 spin_unlock_irqrestore(&priv->q_lock, flags);
708
709 return buf;
710}
711EXPORT_SYMBOL_GPL(imx_media_capture_device_next_buf);
712
713void imx_media_capture_device_error(struct imx_media_video_dev *vdev)
714{
715 struct capture_priv *priv = to_capture_priv(vdev);
716 struct vb2_queue *vq = &priv->q;
717 unsigned long flags;
718
719 if (!vb2_is_streaming(vq))
720 return;
721
722 spin_lock_irqsave(&priv->q_lock, flags);
723 vb2_queue_error(vq);
724 spin_unlock_irqrestore(&priv->q_lock, flags);
725}
726EXPORT_SYMBOL_GPL(imx_media_capture_device_error);
727
728int imx_media_capture_device_register(struct imx_media_video_dev *vdev)
729{
730 struct capture_priv *priv = to_capture_priv(vdev);
731 struct v4l2_subdev *sd = priv->src_sd;
732 struct v4l2_device *v4l2_dev = sd->v4l2_dev;
733 struct video_device *vfd = vdev->vfd;
734 struct vb2_queue *vq = &priv->q;
735 struct v4l2_subdev_format fmt_src;
736 int ret;
737
738
739 priv->md = container_of(v4l2_dev->mdev, struct imx_media_dev, md);
740
741 vfd->v4l2_dev = v4l2_dev;
742
743 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
744 if (ret) {
745 v4l2_err(sd, "Failed to register video device\n");
746 return ret;
747 }
748
749 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
750 vq->io_modes = VB2_MMAP | VB2_DMABUF;
751 vq->drv_priv = priv;
752 vq->buf_struct_size = sizeof(struct imx_media_buffer);
753 vq->ops = &capture_qops;
754 vq->mem_ops = &vb2_dma_contig_memops;
755 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
756 vq->lock = &priv->mutex;
757 vq->min_buffers_needed = 2;
758 vq->dev = priv->dev;
759
760 ret = vb2_queue_init(vq);
761 if (ret) {
762 v4l2_err(sd, "vb2_queue_init failed\n");
763 goto unreg;
764 }
765
766 INIT_LIST_HEAD(&priv->ready_q);
767
768 priv->vdev_pad.flags = MEDIA_PAD_FL_SINK;
769 ret = media_entity_pads_init(&vfd->entity, 1, &priv->vdev_pad);
770 if (ret) {
771 v4l2_err(sd, "failed to init dev pad\n");
772 goto unreg;
773 }
774
775
776 ret = media_create_pad_link(&sd->entity, priv->src_sd_pad,
777 &vfd->entity, 0, 0);
778 if (ret) {
779 v4l2_err(sd, "failed to create link to device node\n");
780 goto unreg;
781 }
782
783
784 fmt_src.pad = priv->src_sd_pad;
785 fmt_src.which = V4L2_SUBDEV_FORMAT_ACTIVE;
786 v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt_src);
787 if (ret) {
788 v4l2_err(sd, "failed to get src_sd format\n");
789 goto unreg;
790 }
791
792 vdev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
793 imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt.fmt.pix,
794 &fmt_src.format, NULL);
795 vdev->compose.width = fmt_src.format.width;
796 vdev->compose.height = fmt_src.format.height;
797 vdev->cc = imx_media_find_format(vdev->fmt.fmt.pix.pixelformat,
798 CS_SEL_ANY, false);
799
800 v4l2_info(sd, "Registered %s as /dev/%s\n", vfd->name,
801 video_device_node_name(vfd));
802
803 vfd->ctrl_handler = &priv->ctrl_hdlr;
804
805
806 imx_media_add_video_device(priv->md, vdev);
807
808 return 0;
809unreg:
810 video_unregister_device(vfd);
811 return ret;
812}
813EXPORT_SYMBOL_GPL(imx_media_capture_device_register);
814
815void imx_media_capture_device_unregister(struct imx_media_video_dev *vdev)
816{
817 struct capture_priv *priv = to_capture_priv(vdev);
818 struct video_device *vfd = priv->vdev.vfd;
819
820 mutex_lock(&priv->mutex);
821
822 if (video_is_registered(vfd)) {
823 video_unregister_device(vfd);
824 media_entity_cleanup(&vfd->entity);
825 }
826
827 mutex_unlock(&priv->mutex);
828}
829EXPORT_SYMBOL_GPL(imx_media_capture_device_unregister);
830
831struct imx_media_video_dev *
832imx_media_capture_device_init(struct device *dev, struct v4l2_subdev *src_sd,
833 int pad)
834{
835 struct capture_priv *priv;
836 struct video_device *vfd;
837
838 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
839 if (!priv)
840 return ERR_PTR(-ENOMEM);
841
842 priv->src_sd = src_sd;
843 priv->src_sd_pad = pad;
844 priv->dev = dev;
845
846 mutex_init(&priv->mutex);
847 spin_lock_init(&priv->q_lock);
848
849 snprintf(capture_videodev.name, sizeof(capture_videodev.name),
850 "%s capture", src_sd->name);
851
852 vfd = video_device_alloc();
853 if (!vfd)
854 return ERR_PTR(-ENOMEM);
855
856 *vfd = capture_videodev;
857 vfd->lock = &priv->mutex;
858 vfd->queue = &priv->q;
859 priv->vdev.vfd = vfd;
860
861 INIT_LIST_HEAD(&priv->vdev.list);
862
863 video_set_drvdata(vfd, priv);
864
865 v4l2_ctrl_handler_init(&priv->ctrl_hdlr, 0);
866
867 return &priv->vdev;
868}
869EXPORT_SYMBOL_GPL(imx_media_capture_device_init);
870
871void imx_media_capture_device_remove(struct imx_media_video_dev *vdev)
872{
873 struct capture_priv *priv = to_capture_priv(vdev);
874
875 v4l2_ctrl_handler_free(&priv->ctrl_hdlr);
876}
877EXPORT_SYMBOL_GPL(imx_media_capture_device_remove);
878
879MODULE_DESCRIPTION("i.MX5/6 v4l2 video capture interface driver");
880MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");
881MODULE_LICENSE("GPL");
882
