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