]> Git Repo - J-linux.git/blob - drivers/staging/media/imx/imx-media-capture.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / drivers / staging / media / imx / imx-media-capture.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Video Capture Subdev for Freescale i.MX5/6 SOC
4  *
5  * Copyright (c) 2012-2016 Mentor Graphics Inc.
6  */
7 #include <linux/delay.h>
8 #include <linux/fs.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"
27
28 #define IMX_CAPTURE_NAME "imx-capture"
29
30 struct capture_priv {
31         struct imx_media_dev *md;               /* Media device */
32         struct device *dev;                     /* Physical device */
33
34         struct imx_media_video_dev vdev;        /* Video device */
35         struct media_pad vdev_pad;              /* Video device pad */
36
37         struct v4l2_subdev *src_sd;             /* Source subdev */
38         int src_sd_pad;                         /* Source subdev pad */
39
40         struct mutex mutex;                     /* Protect vdev operations */
41
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 */
45
46         struct v4l2_ctrl_handler ctrl_hdlr;     /* Controls inherited from subdevs */
47
48         bool legacy_api;                        /* Use the legacy (pre-MC) API */
49 };
50
51 #define to_capture_priv(v) container_of(v, struct capture_priv, vdev)
52
53 /* In bytes, per queue */
54 #define VID_MEM_LIMIT   SZ_64M
55
56 /* -----------------------------------------------------------------------------
57  * MC-Centric Video IOCTLs
58  */
59
60 static const struct imx_media_pixfmt *capture_find_format(u32 code, u32 fourcc)
61 {
62         const struct imx_media_pixfmt *cc;
63
64         cc = imx_media_find_ipu_format(code, PIXFMT_SEL_YUV_RGB);
65         if (cc) {
66                 enum imx_pixfmt_sel fmt_sel = cc->cs == IPUV3_COLORSPACE_YUV
67                                             ? PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
68
69                 cc = imx_media_find_pixel_format(fourcc, fmt_sel);
70                 if (!cc) {
71                         imx_media_enum_pixel_formats(&fourcc, 0, fmt_sel, 0);
72                         cc = imx_media_find_pixel_format(fourcc, fmt_sel);
73                 }
74
75                 return cc;
76         }
77
78         return imx_media_find_mbus_format(code, PIXFMT_SEL_ANY);
79 }
80
81 static int capture_querycap(struct file *file, void *fh,
82                             struct v4l2_capability *cap)
83 {
84         struct capture_priv *priv = video_drvdata(file);
85
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));
90
91         return 0;
92 }
93
94 static int capture_enum_fmt_vid_cap(struct file *file, void *fh,
95                                     struct v4l2_fmtdesc *f)
96 {
97         return imx_media_enum_pixel_formats(&f->pixelformat, f->index,
98                                             PIXFMT_SEL_ANY, f->mbus_code);
99 }
100
101 static int capture_enum_framesizes(struct file *file, void *fh,
102                                    struct v4l2_frmsizeenum *fsize)
103 {
104         const struct imx_media_pixfmt *cc;
105
106         if (fsize->index > 0)
107                 return -EINVAL;
108
109         cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
110         if (!cc)
111                 return -EINVAL;
112
113         /*
114          * TODO: The constraints are hardware-specific and may depend on the
115          * pixel format. This should come from the driver using
116          * imx_media_capture.
117          */
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;
125
126         return 0;
127 }
128
129 static int capture_g_fmt_vid_cap(struct file *file, void *fh,
130                                  struct v4l2_format *f)
131 {
132         struct capture_priv *priv = video_drvdata(file);
133
134         f->fmt.pix = priv->vdev.fmt;
135
136         return 0;
137 }
138
139 static const struct imx_media_pixfmt *
140 __capture_try_fmt(struct v4l2_pix_format *pixfmt, struct v4l2_rect *compose)
141 {
142         struct v4l2_mbus_framefmt fmt_src;
143         const struct imx_media_pixfmt *cc;
144
145         /*
146          * Find the pixel format, default to the first supported format if not
147          * found.
148          */
149         cc = imx_media_find_pixel_format(pixfmt->pixelformat, PIXFMT_SEL_ANY);
150         if (!cc) {
151                 imx_media_enum_pixel_formats(&pixfmt->pixelformat, 0,
152                                              PIXFMT_SEL_ANY, 0);
153                 cc = imx_media_find_pixel_format(pixfmt->pixelformat,
154                                                  PIXFMT_SEL_ANY);
155         }
156
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;
162                         break;
163                 case V4L2_FIELD_SEQ_BT:
164                         pixfmt->field = V4L2_FIELD_INTERLACED_BT;
165                         break;
166                 default:
167                         break;
168                 }
169         }
170
171         v4l2_fill_mbus_format(&fmt_src, pixfmt, 0);
172         imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src, cc);
173
174         if (compose) {
175                 compose->width = fmt_src.width;
176                 compose->height = fmt_src.height;
177         }
178
179         return cc;
180 }
181
182 static int capture_try_fmt_vid_cap(struct file *file, void *fh,
183                                    struct v4l2_format *f)
184 {
185         __capture_try_fmt(&f->fmt.pix, NULL);
186         return 0;
187 }
188
189 static int capture_s_fmt_vid_cap(struct file *file, void *fh,
190                                  struct v4l2_format *f)
191 {
192         struct capture_priv *priv = video_drvdata(file);
193         const struct imx_media_pixfmt *cc;
194
195         if (vb2_is_busy(&priv->q)) {
196                 dev_err(priv->dev, "%s queue busy\n", __func__);
197                 return -EBUSY;
198         }
199
200         cc = __capture_try_fmt(&f->fmt.pix, &priv->vdev.compose);
201
202         priv->vdev.cc = cc;
203         priv->vdev.fmt = f->fmt.pix;
204
205         return 0;
206 }
207
208 static int capture_g_selection(struct file *file, void *fh,
209                                struct v4l2_selection *s)
210 {
211         struct capture_priv *priv = video_drvdata(file);
212
213         switch (s->target) {
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;
219                 break;
220         case V4L2_SEL_TGT_COMPOSE_PADDED:
221                 /*
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.
225                  */
226                 s->r.left = 0;
227                 s->r.top = 0;
228                 s->r.width = priv->vdev.fmt.width;
229                 s->r.height = priv->vdev.fmt.height;
230                 break;
231         default:
232                 return -EINVAL;
233         }
234
235         return 0;
236 }
237
238 static int capture_subscribe_event(struct v4l2_fh *fh,
239                                    const struct v4l2_event_subscription *sub)
240 {
241         switch (sub->type) {
242         case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
243                 return v4l2_event_subscribe(fh, sub, 0, NULL);
244         default:
245                 return -EINVAL;
246         }
247 }
248
249 static const struct v4l2_ioctl_ops capture_ioctl_ops = {
250         .vidioc_querycap                = capture_querycap,
251
252         .vidioc_enum_fmt_vid_cap        = capture_enum_fmt_vid_cap,
253         .vidioc_enum_framesizes         = capture_enum_framesizes,
254
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,
258
259         .vidioc_g_selection             = capture_g_selection,
260
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,
270
271         .vidioc_subscribe_event         = capture_subscribe_event,
272         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
273 };
274
275 /* -----------------------------------------------------------------------------
276  * Legacy Video IOCTLs
277  */
278
279 static int capture_legacy_enum_framesizes(struct file *file, void *fh,
280                                           struct v4l2_frmsizeenum *fsize)
281 {
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,
288         };
289         int ret;
290
291         cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
292         if (!cc)
293                 return -EINVAL;
294
295         fse.code = cc->codes ? cc->codes[0] : 0;
296
297         ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_size, NULL, &fse);
298         if (ret)
299                 return ret;
300
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;
306         } else {
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;
314         }
315
316         return 0;
317 }
318
319 static int capture_legacy_enum_frameintervals(struct file *file, void *fh,
320                                               struct v4l2_frmivalenum *fival)
321 {
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,
330         };
331         int ret;
332
333         cc = imx_media_find_pixel_format(fival->pixel_format, PIXFMT_SEL_ANY);
334         if (!cc)
335                 return -EINVAL;
336
337         fie.code = cc->codes ? cc->codes[0] : 0;
338
339         ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_interval,
340                                NULL, &fie);
341         if (ret)
342                 return ret;
343
344         fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
345         fival->discrete = fie.interval;
346
347         return 0;
348 }
349
350 static int capture_legacy_enum_fmt_vid_cap(struct file *file, void *fh,
351                                            struct v4l2_fmtdesc *f)
352 {
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,
358         };
359         u32 fourcc;
360         int ret;
361
362         ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
363         if (ret) {
364                 dev_err(priv->dev, "failed to get src_sd format\n");
365                 return ret;
366         }
367
368         cc_src = imx_media_find_ipu_format(fmt_src.format.code,
369                                            PIXFMT_SEL_YUV_RGB);
370         if (cc_src) {
371                 enum imx_pixfmt_sel fmt_sel =
372                         (cc_src->cs == IPUV3_COLORSPACE_YUV) ?
373                         PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
374
375                 ret = imx_media_enum_pixel_formats(&fourcc, f->index, fmt_sel,
376                                                    0);
377                 if (ret)
378                         return ret;
379         } else {
380                 cc_src = imx_media_find_mbus_format(fmt_src.format.code,
381                                                     PIXFMT_SEL_ANY);
382                 if (WARN_ON(!cc_src))
383                         return -EINVAL;
384
385                 if (f->index != 0)
386                         return -EINVAL;
387                 fourcc = cc_src->fourcc;
388         }
389
390         f->pixelformat = fourcc;
391
392         return 0;
393 }
394
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)
399 {
400         const struct imx_media_pixfmt *cc;
401
402         cc = capture_find_format(fmt_src->format.code, pixfmt->pixelformat);
403         if (WARN_ON(!cc))
404                 return NULL;
405
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;
411                         break;
412                 case V4L2_FIELD_SEQ_BT:
413                         fmt_src->format.field = V4L2_FIELD_INTERLACED_BT;
414                         break;
415                 default:
416                         break;
417                 }
418         }
419
420         imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src->format, cc);
421
422         return cc;
423 }
424
425 static int capture_legacy_try_fmt_vid_cap(struct file *file, void *fh,
426                                           struct v4l2_format *f)
427 {
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,
432         };
433         int ret;
434
435         ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
436         if (ret)
437                 return ret;
438
439         if (!__capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix))
440                 return -EINVAL;
441
442         return 0;
443 }
444
445 static int capture_legacy_s_fmt_vid_cap(struct file *file, void *fh,
446                                         struct v4l2_format *f)
447 {
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,
452         };
453         const struct imx_media_pixfmt *cc;
454         int ret;
455
456         if (vb2_is_busy(&priv->q)) {
457                 dev_err(priv->dev, "%s queue busy\n", __func__);
458                 return -EBUSY;
459         }
460
461         ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
462         if (ret)
463                 return ret;
464
465         cc = __capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix);
466         if (!cc)
467                 return -EINVAL;
468
469         priv->vdev.cc = cc;
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;
473
474         return 0;
475 }
476
477 static int capture_legacy_querystd(struct file *file, void *fh,
478                                    v4l2_std_id *std)
479 {
480         struct capture_priv *priv = video_drvdata(file);
481
482         return v4l2_subdev_call(priv->src_sd, video, querystd, std);
483 }
484
485 static int capture_legacy_g_std(struct file *file, void *fh, v4l2_std_id *std)
486 {
487         struct capture_priv *priv = video_drvdata(file);
488
489         return v4l2_subdev_call(priv->src_sd, video, g_std, std);
490 }
491
492 static int capture_legacy_s_std(struct file *file, void *fh, v4l2_std_id std)
493 {
494         struct capture_priv *priv = video_drvdata(file);
495
496         if (vb2_is_busy(&priv->q))
497                 return -EBUSY;
498
499         return v4l2_subdev_call(priv->src_sd, video, s_std, std);
500 }
501
502 static int capture_legacy_g_parm(struct file *file, void *fh,
503                                  struct v4l2_streamparm *a)
504 {
505         struct capture_priv *priv = video_drvdata(file);
506         struct v4l2_subdev_frame_interval fi = {
507                 .pad = priv->src_sd_pad,
508         };
509         int ret;
510
511         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
512                 return -EINVAL;
513
514         ret = v4l2_subdev_call_state_active(priv->src_sd, pad,
515                                             get_frame_interval, &fi);
516         if (ret < 0)
517                 return ret;
518
519         a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
520         a->parm.capture.timeperframe = fi.interval;
521
522         return 0;
523 }
524
525 static int capture_legacy_s_parm(struct file *file, void *fh,
526                                  struct v4l2_streamparm *a)
527 {
528         struct capture_priv *priv = video_drvdata(file);
529         struct v4l2_subdev_frame_interval fi = {
530                 .pad = priv->src_sd_pad,
531         };
532         int ret;
533
534         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
535                 return -EINVAL;
536
537         fi.interval = a->parm.capture.timeperframe;
538         ret = v4l2_subdev_call_state_active(priv->src_sd, pad,
539                                             set_frame_interval, &fi);
540         if (ret < 0)
541                 return ret;
542
543         a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
544         a->parm.capture.timeperframe = fi.interval;
545
546         return 0;
547 }
548
549 static int capture_legacy_subscribe_event(struct v4l2_fh *fh,
550                                           const struct v4l2_event_subscription *sub)
551 {
552         switch (sub->type) {
553         case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
554                 return v4l2_event_subscribe(fh, sub, 0, NULL);
555         case V4L2_EVENT_SOURCE_CHANGE:
556                 return v4l2_src_change_event_subscribe(fh, sub);
557         case V4L2_EVENT_CTRL:
558                 return v4l2_ctrl_subscribe_event(fh, sub);
559         default:
560                 return -EINVAL;
561         }
562 }
563
564 static const struct v4l2_ioctl_ops capture_legacy_ioctl_ops = {
565         .vidioc_querycap                = capture_querycap,
566
567         .vidioc_enum_framesizes         = capture_legacy_enum_framesizes,
568         .vidioc_enum_frameintervals     = capture_legacy_enum_frameintervals,
569
570         .vidioc_enum_fmt_vid_cap        = capture_legacy_enum_fmt_vid_cap,
571         .vidioc_g_fmt_vid_cap           = capture_g_fmt_vid_cap,
572         .vidioc_try_fmt_vid_cap         = capture_legacy_try_fmt_vid_cap,
573         .vidioc_s_fmt_vid_cap           = capture_legacy_s_fmt_vid_cap,
574
575         .vidioc_querystd                = capture_legacy_querystd,
576         .vidioc_g_std                   = capture_legacy_g_std,
577         .vidioc_s_std                   = capture_legacy_s_std,
578
579         .vidioc_g_selection             = capture_g_selection,
580
581         .vidioc_g_parm                  = capture_legacy_g_parm,
582         .vidioc_s_parm                  = capture_legacy_s_parm,
583
584         .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
585         .vidioc_create_bufs             = vb2_ioctl_create_bufs,
586         .vidioc_prepare_buf             = vb2_ioctl_prepare_buf,
587         .vidioc_querybuf                = vb2_ioctl_querybuf,
588         .vidioc_qbuf                    = vb2_ioctl_qbuf,
589         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
590         .vidioc_expbuf                  = vb2_ioctl_expbuf,
591         .vidioc_streamon                = vb2_ioctl_streamon,
592         .vidioc_streamoff               = vb2_ioctl_streamoff,
593
594         .vidioc_subscribe_event         = capture_legacy_subscribe_event,
595         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
596 };
597
598 /* -----------------------------------------------------------------------------
599  * Queue Operations
600  */
601
602 static int capture_queue_setup(struct vb2_queue *vq,
603                                unsigned int *nbuffers,
604                                unsigned int *nplanes,
605                                unsigned int sizes[],
606                                struct device *alloc_devs[])
607 {
608         struct capture_priv *priv = vb2_get_drv_priv(vq);
609         struct v4l2_pix_format *pix = &priv->vdev.fmt;
610         unsigned int q_num_bufs = vb2_get_num_buffers(vq);
611         unsigned int count = *nbuffers;
612
613         if (vq->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
614                 return -EINVAL;
615
616         if (*nplanes) {
617                 if (*nplanes != 1 || sizes[0] < pix->sizeimage)
618                         return -EINVAL;
619                 count += q_num_bufs;
620         }
621
622         count = min_t(__u32, VID_MEM_LIMIT / pix->sizeimage, count);
623
624         if (*nplanes)
625                 *nbuffers = (count < q_num_bufs) ? 0 :
626                         count - q_num_bufs;
627         else
628                 *nbuffers = count;
629
630         *nplanes = 1;
631         sizes[0] = pix->sizeimage;
632
633         return 0;
634 }
635
636 static int capture_buf_init(struct vb2_buffer *vb)
637 {
638         struct imx_media_buffer *buf = to_imx_media_vb(vb);
639
640         INIT_LIST_HEAD(&buf->list);
641
642         return 0;
643 }
644
645 static int capture_buf_prepare(struct vb2_buffer *vb)
646 {
647         struct vb2_queue *vq = vb->vb2_queue;
648         struct capture_priv *priv = vb2_get_drv_priv(vq);
649         struct v4l2_pix_format *pix = &priv->vdev.fmt;
650
651         if (vb2_plane_size(vb, 0) < pix->sizeimage) {
652                 dev_err(priv->dev,
653                         "data will not fit into plane (%lu < %lu)\n",
654                         vb2_plane_size(vb, 0), (long)pix->sizeimage);
655                 return -EINVAL;
656         }
657
658         vb2_set_plane_payload(vb, 0, pix->sizeimage);
659
660         return 0;
661 }
662
663 static void capture_buf_queue(struct vb2_buffer *vb)
664 {
665         struct capture_priv *priv = vb2_get_drv_priv(vb->vb2_queue);
666         struct imx_media_buffer *buf = to_imx_media_vb(vb);
667         unsigned long flags;
668
669         spin_lock_irqsave(&priv->q_lock, flags);
670
671         list_add_tail(&buf->list, &priv->ready_q);
672
673         spin_unlock_irqrestore(&priv->q_lock, flags);
674 }
675
676 static int capture_validate_fmt(struct capture_priv *priv)
677 {
678         struct v4l2_subdev_format fmt_src = {
679                 .pad = priv->src_sd_pad,
680                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
681         };
682         const struct imx_media_pixfmt *cc;
683         int ret;
684
685         /* Retrieve the media bus format on the source subdev. */
686         ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
687         if (ret)
688                 return ret;
689
690         /*
691          * Verify that the media bus size matches the size set on the video
692          * node. It is sufficient to check the compose rectangle size without
693          * checking the rounded size from vdev.fmt, as the rounded size is
694          * derived directly from the compose rectangle size, and will thus
695          * always match if the compose rectangle matches.
696          */
697         if (priv->vdev.compose.width != fmt_src.format.width ||
698             priv->vdev.compose.height != fmt_src.format.height)
699                 return -EPIPE;
700
701         /*
702          * Verify that the media bus code is compatible with the pixel format
703          * set on the video node.
704          */
705         cc = capture_find_format(fmt_src.format.code, 0);
706         if (!cc || priv->vdev.cc->cs != cc->cs)
707                 return -EPIPE;
708
709         return 0;
710 }
711
712 static int capture_start_streaming(struct vb2_queue *vq, unsigned int count)
713 {
714         struct capture_priv *priv = vb2_get_drv_priv(vq);
715         struct imx_media_buffer *buf, *tmp;
716         unsigned long flags;
717         int ret;
718
719         ret = capture_validate_fmt(priv);
720         if (ret) {
721                 dev_err(priv->dev, "capture format not valid\n");
722                 goto return_bufs;
723         }
724
725         ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
726                                             true);
727         if (ret) {
728                 dev_err(priv->dev, "pipeline start failed with %d\n", ret);
729                 goto return_bufs;
730         }
731
732         return 0;
733
734 return_bufs:
735         spin_lock_irqsave(&priv->q_lock, flags);
736         list_for_each_entry_safe(buf, tmp, &priv->ready_q, list) {
737                 list_del(&buf->list);
738                 vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_QUEUED);
739         }
740         spin_unlock_irqrestore(&priv->q_lock, flags);
741         return ret;
742 }
743
744 static void capture_stop_streaming(struct vb2_queue *vq)
745 {
746         struct capture_priv *priv = vb2_get_drv_priv(vq);
747         struct imx_media_buffer *frame;
748         struct imx_media_buffer *tmp;
749         unsigned long flags;
750         int ret;
751
752         ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
753                                             false);
754         if (ret)
755                 dev_warn(priv->dev, "pipeline stop failed with %d\n", ret);
756
757         /* release all active buffers */
758         spin_lock_irqsave(&priv->q_lock, flags);
759         list_for_each_entry_safe(frame, tmp, &priv->ready_q, list) {
760                 list_del(&frame->list);
761                 vb2_buffer_done(&frame->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
762         }
763         spin_unlock_irqrestore(&priv->q_lock, flags);
764 }
765
766 static const struct vb2_ops capture_qops = {
767         .queue_setup     = capture_queue_setup,
768         .buf_init        = capture_buf_init,
769         .buf_prepare     = capture_buf_prepare,
770         .buf_queue       = capture_buf_queue,
771         .start_streaming = capture_start_streaming,
772         .stop_streaming  = capture_stop_streaming,
773 };
774
775 /* -----------------------------------------------------------------------------
776  * File Operations
777  */
778
779 static int capture_open(struct file *file)
780 {
781         struct capture_priv *priv = video_drvdata(file);
782         struct video_device *vfd = priv->vdev.vfd;
783         int ret;
784
785         if (mutex_lock_interruptible(&priv->mutex))
786                 return -ERESTARTSYS;
787
788         ret = v4l2_fh_open(file);
789         if (ret) {
790                 dev_err(priv->dev, "v4l2_fh_open failed\n");
791                 goto out;
792         }
793
794         ret = v4l2_pipeline_pm_get(&vfd->entity);
795         if (ret)
796                 v4l2_fh_release(file);
797
798 out:
799         mutex_unlock(&priv->mutex);
800         return ret;
801 }
802
803 static int capture_release(struct file *file)
804 {
805         struct capture_priv *priv = video_drvdata(file);
806         struct video_device *vfd = priv->vdev.vfd;
807         struct vb2_queue *vq = &priv->q;
808
809         mutex_lock(&priv->mutex);
810
811         if (file->private_data == vq->owner) {
812                 vb2_queue_release(vq);
813                 vq->owner = NULL;
814         }
815
816         v4l2_pipeline_pm_put(&vfd->entity);
817
818         v4l2_fh_release(file);
819         mutex_unlock(&priv->mutex);
820         return 0;
821 }
822
823 static const struct v4l2_file_operations capture_fops = {
824         .owner          = THIS_MODULE,
825         .open           = capture_open,
826         .release        = capture_release,
827         .poll           = vb2_fop_poll,
828         .unlocked_ioctl = video_ioctl2,
829         .mmap           = vb2_fop_mmap,
830 };
831
832 /* -----------------------------------------------------------------------------
833  * Public API
834  */
835
836 struct imx_media_buffer *
837 imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev)
838 {
839         struct capture_priv *priv = to_capture_priv(vdev);
840         struct imx_media_buffer *buf = NULL;
841         unsigned long flags;
842
843         spin_lock_irqsave(&priv->q_lock, flags);
844
845         /* get next queued buffer */
846         if (!list_empty(&priv->ready_q)) {
847                 buf = list_entry(priv->ready_q.next, struct imx_media_buffer,
848                                  list);
849                 list_del(&buf->list);
850         }
851
852         spin_unlock_irqrestore(&priv->q_lock, flags);
853
854         return buf;
855 }
856 EXPORT_SYMBOL_GPL(imx_media_capture_device_next_buf);
857
858 void imx_media_capture_device_error(struct imx_media_video_dev *vdev)
859 {
860         struct capture_priv *priv = to_capture_priv(vdev);
861         struct vb2_queue *vq = &priv->q;
862         unsigned long flags;
863
864         if (!vb2_is_streaming(vq))
865                 return;
866
867         spin_lock_irqsave(&priv->q_lock, flags);
868         vb2_queue_error(vq);
869         spin_unlock_irqrestore(&priv->q_lock, flags);
870 }
871 EXPORT_SYMBOL_GPL(imx_media_capture_device_error);
872
873 static int capture_init_format(struct capture_priv *priv)
874 {
875         struct v4l2_subdev_format fmt_src = {
876                 .pad = priv->src_sd_pad,
877                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
878         };
879         struct imx_media_video_dev *vdev = &priv->vdev;
880         int ret;
881
882         if (priv->legacy_api) {
883                 ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL,
884                                        &fmt_src);
885                 if (ret) {
886                         dev_err(priv->dev, "failed to get source format\n");
887                         return ret;
888                 }
889         } else {
890                 fmt_src.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
891                 fmt_src.format.width = IMX_MEDIA_DEF_PIX_WIDTH;
892                 fmt_src.format.height = IMX_MEDIA_DEF_PIX_HEIGHT;
893         }
894
895         imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt, &fmt_src.format, NULL);
896         vdev->compose.width = fmt_src.format.width;
897         vdev->compose.height = fmt_src.format.height;
898
899         vdev->cc = imx_media_find_pixel_format(vdev->fmt.pixelformat,
900                                                PIXFMT_SEL_ANY);
901
902         return 0;
903 }
904
905 int imx_media_capture_device_register(struct imx_media_video_dev *vdev,
906                                       u32 link_flags)
907 {
908         struct capture_priv *priv = to_capture_priv(vdev);
909         struct v4l2_subdev *sd = priv->src_sd;
910         struct v4l2_device *v4l2_dev = sd->v4l2_dev;
911         struct video_device *vfd = vdev->vfd;
912         int ret;
913
914         /* get media device */
915         priv->md = container_of(v4l2_dev->mdev, struct imx_media_dev, md);
916
917         vfd->v4l2_dev = v4l2_dev;
918
919         /* Initialize the default format and compose rectangle. */
920         ret = capture_init_format(priv);
921         if (ret < 0)
922                 return ret;
923
924         /* Register the video device. */
925         ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1);
926         if (ret) {
927                 dev_err(priv->dev, "Failed to register video device\n");
928                 return ret;
929         }
930
931         dev_info(priv->dev, "Registered %s as /dev/%s\n", vfd->name,
932                  video_device_node_name(vfd));
933
934         /* Create the link from the src_sd devnode pad to device node. */
935         if (link_flags & MEDIA_LNK_FL_IMMUTABLE)
936                 link_flags |= MEDIA_LNK_FL_ENABLED;
937         ret = media_create_pad_link(&sd->entity, priv->src_sd_pad,
938                                     &vfd->entity, 0, link_flags);
939         if (ret) {
940                 dev_err(priv->dev, "failed to create link to device node\n");
941                 video_unregister_device(vfd);
942                 return ret;
943         }
944
945         /* Add vdev to the video devices list. */
946         imx_media_add_video_device(priv->md, vdev);
947
948         return 0;
949 }
950 EXPORT_SYMBOL_GPL(imx_media_capture_device_register);
951
952 void imx_media_capture_device_unregister(struct imx_media_video_dev *vdev)
953 {
954         struct capture_priv *priv = to_capture_priv(vdev);
955         struct video_device *vfd = priv->vdev.vfd;
956
957         media_entity_cleanup(&vfd->entity);
958         video_unregister_device(vfd);
959 }
960 EXPORT_SYMBOL_GPL(imx_media_capture_device_unregister);
961
962 struct imx_media_video_dev *
963 imx_media_capture_device_init(struct device *dev, struct v4l2_subdev *src_sd,
964                               int pad, bool legacy_api)
965 {
966         struct capture_priv *priv;
967         struct video_device *vfd;
968         struct vb2_queue *vq;
969         int ret;
970
971         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
972         if (!priv)
973                 return ERR_PTR(-ENOMEM);
974
975         priv->src_sd = src_sd;
976         priv->src_sd_pad = pad;
977         priv->dev = dev;
978         priv->legacy_api = legacy_api;
979
980         mutex_init(&priv->mutex);
981         INIT_LIST_HEAD(&priv->ready_q);
982         spin_lock_init(&priv->q_lock);
983
984         /* Allocate and initialize the video device. */
985         vfd = video_device_alloc();
986         if (!vfd)
987                 return ERR_PTR(-ENOMEM);
988
989         vfd->fops = &capture_fops;
990         vfd->ioctl_ops = legacy_api ? &capture_legacy_ioctl_ops
991                        : &capture_ioctl_ops;
992         vfd->minor = -1;
993         vfd->release = video_device_release;
994         vfd->vfl_dir = VFL_DIR_RX;
995         vfd->tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
996         vfd->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING
997                          | (!legacy_api ? V4L2_CAP_IO_MC : 0);
998         vfd->lock = &priv->mutex;
999         vfd->queue = &priv->q;
1000
1001         snprintf(vfd->name, sizeof(vfd->name), "%s capture", src_sd->name);
1002
1003         video_set_drvdata(vfd, priv);
1004         priv->vdev.vfd = vfd;
1005         INIT_LIST_HEAD(&priv->vdev.list);
1006
1007         /* Initialize the video device pad. */
1008         priv->vdev_pad.flags = MEDIA_PAD_FL_SINK;
1009         ret = media_entity_pads_init(&vfd->entity, 1, &priv->vdev_pad);
1010         if (ret) {
1011                 video_device_release(vfd);
1012                 return ERR_PTR(ret);
1013         }
1014
1015         /* Initialize the vb2 queue. */
1016         vq = &priv->q;
1017         vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1018         vq->io_modes = VB2_MMAP | VB2_DMABUF;
1019         vq->drv_priv = priv;
1020         vq->buf_struct_size = sizeof(struct imx_media_buffer);
1021         vq->ops = &capture_qops;
1022         vq->mem_ops = &vb2_dma_contig_memops;
1023         vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1024         vq->lock = &priv->mutex;
1025         vq->min_queued_buffers = 2;
1026         vq->dev = priv->dev;
1027
1028         ret = vb2_queue_init(vq);
1029         if (ret) {
1030                 dev_err(priv->dev, "vb2_queue_init failed\n");
1031                 video_device_release(vfd);
1032                 return ERR_PTR(ret);
1033         }
1034
1035         if (legacy_api) {
1036                 /* Initialize the control handler. */
1037                 v4l2_ctrl_handler_init(&priv->ctrl_hdlr, 0);
1038                 vfd->ctrl_handler = &priv->ctrl_hdlr;
1039         }
1040
1041         return &priv->vdev;
1042 }
1043 EXPORT_SYMBOL_GPL(imx_media_capture_device_init);
1044
1045 void imx_media_capture_device_remove(struct imx_media_video_dev *vdev)
1046 {
1047         struct capture_priv *priv = to_capture_priv(vdev);
1048
1049         v4l2_ctrl_handler_free(&priv->ctrl_hdlr);
1050 }
1051 EXPORT_SYMBOL_GPL(imx_media_capture_device_remove);
1052
1053 MODULE_DESCRIPTION("i.MX5/6 v4l2 video capture interface driver");
1054 MODULE_AUTHOR("Steve Longerbeam <[email protected]>");
1055 MODULE_LICENSE("GPL");
This page took 0.12587 seconds and 4 git commands to generate.