drivers/media/platform/verisilicon/hantro_v4l2.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Hantro VPU codec driver
   4  *
   5  * Copyright (C) 2018 Collabora, Ltd.
   6  * Copyright (C) 2018 Rockchip Electronics Co., Ltd.
   7  *      Alpha Lin <Alpha.Lin@rock-chips.com>
   8  *      Jeffy Chen <jeffy.chen@rock-chips.com>
   9  *
  10  * Copyright 2018 Google LLC.
  11  *      Tomasz Figa <tfiga@chromium.org>
  12  *
  13  * Based on s5p-mfc driver by Samsung Electronics Co., Ltd.
  14  * Copyright (C) 2010-2011 Samsung Electronics Co., Ltd.
  15  */
  16
  17 #include <linux/interrupt.h>
  18 #include <linux/io.h>
  19 #include <linux/module.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/videodev2.h>
  22 #include <linux/workqueue.h>
  23 #include <media/v4l2-ctrls.h>
  24 #include <media/v4l2-event.h>
  25 #include <media/v4l2-mem2mem.h>
  26
  27 #include "hantro.h"
  28 #include "hantro_hw.h"
  29 #include "hantro_v4l2.h"
  30
  31 #define  HANTRO_DEFAULT_BIT_DEPTH 8
  32
  33 static int hantro_set_fmt_out(struct hantro_ctx *ctx,
  34                               struct v4l2_pix_format_mplane *pix_mp);
  35 static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
  36                               struct v4l2_pix_format_mplane *pix_mp);
  37
  38 static const struct hantro_fmt *
  39 hantro_get_formats(const struct hantro_ctx *ctx, unsigned int *num_fmts)
  40 {
  41         const struct hantro_fmt *formats;
  42
  43         if (ctx->is_encoder) {
  44                 formats = ctx->dev->variant->enc_fmts;
  45                 *num_fmts = ctx->dev->variant->num_enc_fmts;
  46         } else {
  47                 formats = ctx->dev->variant->dec_fmts;
  48                 *num_fmts = ctx->dev->variant->num_dec_fmts;
  49         }
  50
  51         return formats;
  52 }
  53
  54 static const struct hantro_fmt *
  55 hantro_get_postproc_formats(const struct hantro_ctx *ctx,
  56                             unsigned int *num_fmts)
  57 {
  58         struct hantro_dev *vpu = ctx->dev;
  59
  60         if (ctx->is_encoder || !vpu->variant->postproc_fmts) {
  61                 *num_fmts = 0;
  62                 return NULL;
  63         }
  64
  65         *num_fmts = ctx->dev->variant->num_postproc_fmts;
  66         return ctx->dev->variant->postproc_fmts;
  67 }
  68
  69 int hantro_get_format_depth(u32 fourcc)
  70 {
  71         switch (fourcc) {
  72         case V4L2_PIX_FMT_P010:
  73         case V4L2_PIX_FMT_P010_4L4:
  74                 return 10;
  75         default:
  76                 return 8;
  77         }
  78 }
  79
  80 static bool
  81 hantro_check_depth_match(const struct hantro_fmt *fmt, int bit_depth)
  82 {
  83         int fmt_depth;
  84
  85         if (!fmt->match_depth && !fmt->postprocessed)
  86                 return true;
  87
  88         fmt_depth = hantro_get_format_depth(fmt->fourcc);
  89
  90         /*
  91          * Allow only downconversion for postproc formats for now.
  92          * It may be possible to relax that on some HW.
  93          */
  94         if (!fmt->match_depth)
  95                 return fmt_depth <= bit_depth;
  96
  97         return fmt_depth == bit_depth;
  98 }
  99
 100 static const struct hantro_fmt *
 101 hantro_find_format(const struct hantro_ctx *ctx, u32 fourcc)
 102 {
 103         const struct hantro_fmt *formats;
 104         unsigned int i, num_fmts;
 105
 106         formats = hantro_get_formats(ctx, &num_fmts);
 107         for (i = 0; i < num_fmts; i++)
 108                 if (formats[i].fourcc == fourcc)
 109                         return &formats[i];
 110
 111         formats = hantro_get_postproc_formats(ctx, &num_fmts);
 112         for (i = 0; i < num_fmts; i++)
 113                 if (formats[i].fourcc == fourcc)
 114                         return &formats[i];
 115         return NULL;
 116 }
 117
 118 const struct hantro_fmt *
 119 hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream, int bit_depth)
 120 {
 121         const struct hantro_fmt *formats;
 122         unsigned int i, num_fmts;
 123
 124         formats = hantro_get_formats(ctx, &num_fmts);
 125         for (i = 0; i < num_fmts; i++) {
 126                 if (bitstream == (formats[i].codec_mode !=
 127                                   HANTRO_MODE_NONE) &&
 128                     hantro_check_depth_match(&formats[i], bit_depth))
 129                         return &formats[i];
 130         }
 131         return NULL;
 132 }
 133
 134 static int vidioc_querycap(struct file *file, void *priv,
 135                            struct v4l2_capability *cap)
 136 {
 137         struct hantro_dev *vpu = video_drvdata(file);
 138         struct video_device *vdev = video_devdata(file);
 139
 140         strscpy(cap->driver, vpu->dev->driver->name, sizeof(cap->driver));
 141         strscpy(cap->card, vdev->name, sizeof(cap->card));
 142         return 0;
 143 }
 144
 145 static int vidioc_enum_framesizes(struct file *file, void *priv,
 146                                   struct v4l2_frmsizeenum *fsize)
 147 {
 148         struct hantro_ctx *ctx = fh_to_ctx(priv);
 149         const struct hantro_fmt *fmt;
 150
 151         fmt = hantro_find_format(ctx, fsize->pixel_format);
 152         if (!fmt) {
 153                 vpu_debug(0, "unsupported bitstream format (%08x)\n",
 154                           fsize->pixel_format);
 155                 return -EINVAL;
 156         }
 157
 158         /* For non-coded formats check if postprocessing scaling is possible */
 159         if (fmt->codec_mode == HANTRO_MODE_NONE) {
 160                 if (hantro_needs_postproc(ctx, fmt))
 161                         return hanto_postproc_enum_framesizes(ctx, fsize);
 162                 else
 163                         return -ENOTTY;
 164         } else if (fsize->index != 0) {
 165                 vpu_debug(0, "invalid frame size index (expected 0, got %d)\n",
 166                           fsize->index);
 167                 return -EINVAL;
 168         }
 169
 170         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
 171         fsize->stepwise = fmt->frmsize;
 172
 173         return 0;
 174 }
 175
 176 static int vidioc_enum_fmt(struct file *file, void *priv,
 177                            struct v4l2_fmtdesc *f, bool capture)
 178
 179 {
 180         struct hantro_ctx *ctx = fh_to_ctx(priv);
 181         const struct hantro_fmt *fmt, *formats;
 182         unsigned int num_fmts, i, j = 0;
 183         bool skip_mode_none;
 184
 185         /*
 186          * When dealing with an encoder:
 187          *  - on the capture side we want to filter out all MODE_NONE formats.
 188          *  - on the output side we want to filter out all formats that are
 189          *    not MODE_NONE.
 190          * When dealing with a decoder:
 191          *  - on the capture side we want to filter out all formats that are
 192          *    not MODE_NONE.
 193          *  - on the output side we want to filter out all MODE_NONE formats.
 194          */
 195         skip_mode_none = capture == ctx->is_encoder;
 196
 197         formats = hantro_get_formats(ctx, &num_fmts);
 198         for (i = 0; i < num_fmts; i++) {
 199                 bool mode_none = formats[i].codec_mode == HANTRO_MODE_NONE;
 200                 fmt = &formats[i];
 201
 202                 if (skip_mode_none == mode_none)
 203                         continue;
 204                 if (!hantro_check_depth_match(fmt, ctx->bit_depth))
 205                         continue;
 206                 if (j == f->index) {
 207                         f->pixelformat = fmt->fourcc;
 208                         return 0;
 209                 }
 210                 ++j;
 211         }
 212
 213         /*
 214          * Enumerate post-processed formats. As per the specification,
 215          * we enumerated these formats after natively decoded formats
 216          * as a hint for applications on what's the preferred fomat.
 217          */
 218         if (!capture)
 219                 return -EINVAL;
 220         formats = hantro_get_postproc_formats(ctx, &num_fmts);
 221         for (i = 0; i < num_fmts; i++) {
 222                 fmt = &formats[i];
 223
 224                 if (!hantro_check_depth_match(fmt, ctx->bit_depth))
 225                         continue;
 226                 if (j == f->index) {
 227                         f->pixelformat = fmt->fourcc;
 228                         return 0;
 229                 }
 230                 ++j;
 231         }
 232
 233         return -EINVAL;
 234 }
 235
 236 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
 237                                    struct v4l2_fmtdesc *f)
 238 {
 239         return vidioc_enum_fmt(file, priv, f, true);
 240 }
 241
 242 static int vidioc_enum_fmt_vid_out(struct file *file, void *priv,
 243                                    struct v4l2_fmtdesc *f)
 244 {
 245         return vidioc_enum_fmt(file, priv, f, false);
 246 }
 247
 248 static int vidioc_g_fmt_out_mplane(struct file *file, void *priv,
 249                                    struct v4l2_format *f)
 250 {
 251         struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
 252         struct hantro_ctx *ctx = fh_to_ctx(priv);
 253
 254         vpu_debug(4, "f->type = %d\n", f->type);
 255
 256         *pix_mp = ctx->src_fmt;
 257
 258         return 0;
 259 }
 260
 261 static int vidioc_g_fmt_cap_mplane(struct file *file, void *priv,
 262                                    struct v4l2_format *f)
 263 {
 264         struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
 265         struct hantro_ctx *ctx = fh_to_ctx(priv);
 266
 267         vpu_debug(4, "f->type = %d\n", f->type);
 268
 269         *pix_mp = ctx->dst_fmt;
 270
 271         return 0;
 272 }
 273
 274 static int hantro_try_fmt(const struct hantro_ctx *ctx,
 275                           struct v4l2_pix_format_mplane *pix_mp,
 276                           enum v4l2_buf_type type)
 277 {
 278         const struct hantro_fmt *fmt;
 279         bool capture = V4L2_TYPE_IS_CAPTURE(type);
 280         bool coded;
 281
 282         coded = capture == ctx->is_encoder;
 283
 284         vpu_debug(4, "trying format %c%c%c%c\n",
 285                   (pix_mp->pixelformat & 0x7f),
 286                   (pix_mp->pixelformat >> 8) & 0x7f,
 287                   (pix_mp->pixelformat >> 16) & 0x7f,
 288                   (pix_mp->pixelformat >> 24) & 0x7f);
 289
 290         fmt = hantro_find_format(ctx, pix_mp->pixelformat);
 291         if (!fmt) {
 292                 fmt = hantro_get_default_fmt(ctx, coded, HANTRO_DEFAULT_BIT_DEPTH);
 293                 pix_mp->pixelformat = fmt->fourcc;
 294         }
 295
 296         if (coded) {
 297                 pix_mp->num_planes = 1;
 298         } else if (!ctx->is_encoder) {
 299                 /*
 300                  * Width/height on the CAPTURE end of a decoder are ignored and
 301                  * replaced by the OUTPUT ones.
 302                  */
 303                 pix_mp->width = ctx->src_fmt.width;
 304                 pix_mp->height = ctx->src_fmt.height;
 305         }
 306
 307         pix_mp->field = V4L2_FIELD_NONE;
 308
 309         v4l2_apply_frmsize_constraints(&pix_mp->width, &pix_mp->height,
 310                                        &fmt->frmsize);
 311
 312         if (!coded) {
 313                 /* Fill remaining fields */
 314                 v4l2_fill_pixfmt_mp(pix_mp, fmt->fourcc, pix_mp->width,
 315                                     pix_mp->height);
 316                 if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_H264_SLICE &&
 317                     !hantro_needs_postproc(ctx, fmt))
 318                         pix_mp->plane_fmt[0].sizeimage +=
 319                                 hantro_h264_mv_size(pix_mp->width,
 320                                                     pix_mp->height);
 321                 else if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_VP9_FRAME &&
 322                          !hantro_needs_postproc(ctx, fmt))
 323                         pix_mp->plane_fmt[0].sizeimage +=
 324                                 hantro_vp9_mv_size(pix_mp->width,
 325                                                    pix_mp->height);
 326                 else if (ctx->vpu_src_fmt->fourcc == V4L2_PIX_FMT_HEVC_SLICE &&
 327                          !hantro_needs_postproc(ctx, fmt))
 328                         pix_mp->plane_fmt[0].sizeimage +=
 329                                 hantro_hevc_mv_size(pix_mp->width,
 330                                                     pix_mp->height);
 331         } else if (!pix_mp->plane_fmt[0].sizeimage) {
 332                 /*
 333                  * For coded formats the application can specify
 334                  * sizeimage. If the application passes a zero sizeimage,
 335                  * let's default to the maximum frame size.
 336                  */
 337                 pix_mp->plane_fmt[0].sizeimage = fmt->header_size +
 338                         pix_mp->width * pix_mp->height * fmt->max_depth;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static int vidioc_try_fmt_cap_mplane(struct file *file, void *priv,
 345                                      struct v4l2_format *f)
 346 {
 347         return hantro_try_fmt(fh_to_ctx(priv), &f->fmt.pix_mp, f->type);
 348 }
 349
 350 static int vidioc_try_fmt_out_mplane(struct file *file, void *priv,
 351                                      struct v4l2_format *f)
 352 {
 353         return hantro_try_fmt(fh_to_ctx(priv), &f->fmt.pix_mp, f->type);
 354 }
 355
 356 static void
 357 hantro_reset_fmt(struct v4l2_pix_format_mplane *fmt,
 358                  const struct hantro_fmt *vpu_fmt)
 359 {
 360         memset(fmt, 0, sizeof(*fmt));
 361
 362         fmt->pixelformat = vpu_fmt->fourcc;
 363         fmt->field = V4L2_FIELD_NONE;
 364         fmt->colorspace = V4L2_COLORSPACE_JPEG;
 365         fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 366         fmt->quantization = V4L2_QUANTIZATION_DEFAULT;
 367         fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT;
 368 }
 369
 370 static void
 371 hantro_reset_encoded_fmt(struct hantro_ctx *ctx)
 372 {
 373         const struct hantro_fmt *vpu_fmt;
 374         struct v4l2_pix_format_mplane fmt;
 375
 376         vpu_fmt = hantro_get_default_fmt(ctx, true, HANTRO_DEFAULT_BIT_DEPTH);
 377         if (!vpu_fmt)
 378                 return;
 379
 380         hantro_reset_fmt(&fmt, vpu_fmt);
 381         fmt.width = vpu_fmt->frmsize.min_width;
 382         fmt.height = vpu_fmt->frmsize.min_height;
 383         if (ctx->is_encoder)
 384                 hantro_set_fmt_cap(ctx, &fmt);
 385         else
 386                 hantro_set_fmt_out(ctx, &fmt);
 387 }
 388
 389 int
 390 hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth)
 391 {
 392         const struct hantro_fmt *raw_vpu_fmt;
 393         struct v4l2_pix_format_mplane raw_fmt, *encoded_fmt;
 394         int ret;
 395
 396         raw_vpu_fmt = hantro_get_default_fmt(ctx, false, bit_depth);
 397         if (!raw_vpu_fmt)
 398                 return -EINVAL;
 399
 400         if (ctx->is_encoder) {
 401                 encoded_fmt = &ctx->dst_fmt;
 402                 ctx->vpu_src_fmt = raw_vpu_fmt;
 403         } else {
 404                 encoded_fmt = &ctx->src_fmt;
 405         }
 406
 407         hantro_reset_fmt(&raw_fmt, raw_vpu_fmt);
 408         raw_fmt.width = encoded_fmt->width;
 409         raw_fmt.height = encoded_fmt->height;
 410         if (ctx->is_encoder)
 411                 ret = hantro_set_fmt_out(ctx, &raw_fmt);
 412         else
 413                 ret = hantro_set_fmt_cap(ctx, &raw_fmt);
 414
 415         if (!ret)
 416                 ctx->bit_depth = bit_depth;
 417
 418         return ret;
 419 }
 420
 421 void hantro_reset_fmts(struct hantro_ctx *ctx)
 422 {
 423         hantro_reset_encoded_fmt(ctx);
 424         hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH);
 425 }
 426
 427 static void
 428 hantro_update_requires_request(struct hantro_ctx *ctx, u32 fourcc)
 429 {
 430         switch (fourcc) {
 431         case V4L2_PIX_FMT_JPEG:
 432                 ctx->fh.m2m_ctx->out_q_ctx.q.requires_requests = false;
 433                 break;
 434         case V4L2_PIX_FMT_MPEG2_SLICE:
 435         case V4L2_PIX_FMT_VP8_FRAME:
 436         case V4L2_PIX_FMT_H264_SLICE:
 437         case V4L2_PIX_FMT_HEVC_SLICE:
 438         case V4L2_PIX_FMT_VP9_FRAME:
 439                 ctx->fh.m2m_ctx->out_q_ctx.q.requires_requests = true;
 440                 break;
 441         default:
 442                 break;
 443         }
 444 }
 445
 446 static void
 447 hantro_update_requires_hold_capture_buf(struct hantro_ctx *ctx, u32 fourcc)
 448 {
 449         struct vb2_queue *vq;
 450
 451         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 452                              V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 453
 454         switch (fourcc) {
 455         case V4L2_PIX_FMT_JPEG:
 456         case V4L2_PIX_FMT_MPEG2_SLICE:
 457         case V4L2_PIX_FMT_VP8_FRAME:
 458         case V4L2_PIX_FMT_HEVC_SLICE:
 459         case V4L2_PIX_FMT_VP9_FRAME:
 460                 vq->subsystem_flags &= ~(VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF);
 461                 break;
 462         case V4L2_PIX_FMT_H264_SLICE:
 463                 vq->subsystem_flags |= VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF;
 464                 break;
 465         default:
 466                 break;
 467         }
 468 }
 469
 470 static int hantro_set_fmt_out(struct hantro_ctx *ctx,
 471                               struct v4l2_pix_format_mplane *pix_mp)
 472 {
 473         struct vb2_queue *vq;
 474         int ret;
 475
 476         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 477                              V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 478         ret = hantro_try_fmt(ctx, pix_mp, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 479         if (ret)
 480                 return ret;
 481
 482         if (!ctx->is_encoder) {
 483                 struct vb2_queue *peer_vq;
 484
 485                 /*
 486                  * In order to support dynamic resolution change,
 487                  * the decoder admits a resolution change, as long
 488                  * as the pixelformat remains. Can't be done if streaming.
 489                  */
 490                 if (vb2_is_streaming(vq) || (vb2_is_busy(vq) &&
 491                     pix_mp->pixelformat != ctx->src_fmt.pixelformat))
 492                         return -EBUSY;
 493                 /*
 494                  * Since format change on the OUTPUT queue will reset
 495                  * the CAPTURE queue, we can't allow doing so
 496                  * when the CAPTURE queue has buffers allocated.
 497                  */
 498                 peer_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 499                                           V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 500                 if (vb2_is_busy(peer_vq))
 501                         return -EBUSY;
 502         } else {
 503                 /*
 504                  * The encoder doesn't admit a format change if
 505                  * there are OUTPUT buffers allocated.
 506                  */
 507                 if (vb2_is_busy(vq))
 508                         return -EBUSY;
 509         }
 510
 511         ctx->vpu_src_fmt = hantro_find_format(ctx, pix_mp->pixelformat);
 512         ctx->src_fmt = *pix_mp;
 513
 514         /*
 515          * Current raw format might have become invalid with newly
 516          * selected codec, so reset it to default just to be safe and
 517          * keep internal driver state sane. User is mandated to set
 518          * the raw format again after we return, so we don't need
 519          * anything smarter.
 520          * Note that hantro_reset_raw_fmt() also propagates size
 521          * changes to the raw format.
 522          */
 523         if (!ctx->is_encoder)
 524                 hantro_reset_raw_fmt(ctx, hantro_get_format_depth(pix_mp->pixelformat));
 525
 526         /* Colorimetry information are always propagated. */
 527         ctx->dst_fmt.colorspace = pix_mp->colorspace;
 528         ctx->dst_fmt.ycbcr_enc = pix_mp->ycbcr_enc;
 529         ctx->dst_fmt.xfer_func = pix_mp->xfer_func;
 530         ctx->dst_fmt.quantization = pix_mp->quantization;
 531
 532         hantro_update_requires_request(ctx, pix_mp->pixelformat);
 533         hantro_update_requires_hold_capture_buf(ctx, pix_mp->pixelformat);
 534
 535         vpu_debug(0, "OUTPUT codec mode: %d\n", ctx->vpu_src_fmt->codec_mode);
 536         vpu_debug(0, "fmt - w: %d, h: %d\n",
 537                   pix_mp->width, pix_mp->height);
 538         return 0;
 539 }
 540
 541 static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
 542                               struct v4l2_pix_format_mplane *pix_mp)
 543 {
 544         struct vb2_queue *vq;
 545         int ret;
 546
 547         /* Change not allowed if queue is busy. */
 548         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 549                              V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 550         if (vb2_is_busy(vq))
 551                 return -EBUSY;
 552
 553         if (ctx->is_encoder) {
 554                 struct vb2_queue *peer_vq;
 555
 556                 /*
 557                  * Since format change on the CAPTURE queue will reset
 558                  * the OUTPUT queue, we can't allow doing so
 559                  * when the OUTPUT queue has buffers allocated.
 560                  */
 561                 peer_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 562                                           V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 563                 if (vb2_is_busy(peer_vq) &&
 564                     (pix_mp->pixelformat != ctx->dst_fmt.pixelformat ||
 565                      pix_mp->height != ctx->dst_fmt.height ||
 566                      pix_mp->width != ctx->dst_fmt.width))
 567                         return -EBUSY;
 568         }
 569
 570         ret = hantro_try_fmt(ctx, pix_mp, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 571         if (ret)
 572                 return ret;
 573
 574         ctx->vpu_dst_fmt = hantro_find_format(ctx, pix_mp->pixelformat);
 575         ctx->dst_fmt = *pix_mp;
 576
 577         /*
 578          * Current raw format might have become invalid with newly
 579          * selected codec, so reset it to default just to be safe and
 580          * keep internal driver state sane. User is mandated to set
 581          * the raw format again after we return, so we don't need
 582          * anything smarter.
 583          * Note that hantro_reset_raw_fmt() also propagates size
 584          * changes to the raw format.
 585          */
 586         if (ctx->is_encoder)
 587                 hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH);
 588
 589         /* Colorimetry information are always propagated. */
 590         ctx->src_fmt.colorspace = pix_mp->colorspace;
 591         ctx->src_fmt.ycbcr_enc = pix_mp->ycbcr_enc;
 592         ctx->src_fmt.xfer_func = pix_mp->xfer_func;
 593         ctx->src_fmt.quantization = pix_mp->quantization;
 594
 595         vpu_debug(0, "CAPTURE codec mode: %d\n", ctx->vpu_dst_fmt->codec_mode);
 596         vpu_debug(0, "fmt - w: %d, h: %d\n",
 597                   pix_mp->width, pix_mp->height);
 598
 599         hantro_update_requires_request(ctx, pix_mp->pixelformat);
 600
 601         return 0;
 602 }
 603
 604 static int
 605 vidioc_s_fmt_out_mplane(struct file *file, void *priv, struct v4l2_format *f)
 606 {
 607         return hantro_set_fmt_out(fh_to_ctx(priv), &f->fmt.pix_mp);
 608 }
 609
 610 static int
 611 vidioc_s_fmt_cap_mplane(struct file *file, void *priv, struct v4l2_format *f)
 612 {
 613         return hantro_set_fmt_cap(fh_to_ctx(priv), &f->fmt.pix_mp);
 614 }
 615
 616 static int vidioc_g_selection(struct file *file, void *priv,
 617                               struct v4l2_selection *sel)
 618 {
 619         struct hantro_ctx *ctx = fh_to_ctx(priv);
 620
 621         /* Crop only supported on source. */
 622         if (!ctx->is_encoder ||
 623             sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 624                 return -EINVAL;
 625
 626         switch (sel->target) {
 627         case V4L2_SEL_TGT_CROP_DEFAULT:
 628         case V4L2_SEL_TGT_CROP_BOUNDS:
 629                 sel->r.top = 0;
 630                 sel->r.left = 0;
 631                 sel->r.width = ctx->src_fmt.width;
 632                 sel->r.height = ctx->src_fmt.height;
 633                 break;
 634         case V4L2_SEL_TGT_CROP:
 635                 sel->r.top = 0;
 636                 sel->r.left = 0;
 637                 sel->r.width = ctx->dst_fmt.width;
 638                 sel->r.height = ctx->dst_fmt.height;
 639                 break;
 640         default:
 641                 return -EINVAL;
 642         }
 643
 644         return 0;
 645 }
 646
 647 static int vidioc_s_selection(struct file *file, void *priv,
 648                               struct v4l2_selection *sel)
 649 {
 650         struct hantro_ctx *ctx = fh_to_ctx(priv);
 651         struct v4l2_rect *rect = &sel->r;
 652         struct vb2_queue *vq;
 653
 654         /* Crop only supported on source. */
 655         if (!ctx->is_encoder ||
 656             sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 657                 return -EINVAL;
 658
 659         /* Change not allowed if the queue is streaming. */
 660         vq = v4l2_m2m_get_src_vq(ctx->fh.m2m_ctx);
 661         if (vb2_is_streaming(vq))
 662                 return -EBUSY;
 663
 664         if (sel->target != V4L2_SEL_TGT_CROP)
 665                 return -EINVAL;
 666
 667         /*
 668          * We do not support offsets, and we can crop only inside
 669          * right-most or bottom-most macroblocks.
 670          */
 671         if (rect->left != 0 || rect->top != 0 ||
 672             round_up(rect->width, MB_DIM) != ctx->src_fmt.width ||
 673             round_up(rect->height, MB_DIM) != ctx->src_fmt.height) {
 674                 /* Default to full frame for incorrect settings. */
 675                 rect->left = 0;
 676                 rect->top = 0;
 677                 rect->width = ctx->src_fmt.width;
 678                 rect->height = ctx->src_fmt.height;
 679         } else {
 680                 /* We support widths aligned to 4 pixels and arbitrary heights. */
 681                 rect->width = round_up(rect->width, 4);
 682         }
 683
 684         ctx->dst_fmt.width = rect->width;
 685         ctx->dst_fmt.height = rect->height;
 686
 687         return 0;
 688 }
 689
 690 static const struct v4l2_event hantro_eos_event = {
 691         .type = V4L2_EVENT_EOS
 692 };
 693
 694 static int vidioc_encoder_cmd(struct file *file, void *priv,
 695                               struct v4l2_encoder_cmd *ec)
 696 {
 697         struct hantro_ctx *ctx = fh_to_ctx(priv);
 698         int ret;
 699
 700         ret = v4l2_m2m_ioctl_try_encoder_cmd(file, priv, ec);
 701         if (ret < 0)
 702                 return ret;
 703
 704         if (!vb2_is_streaming(v4l2_m2m_get_src_vq(ctx->fh.m2m_ctx)) ||
 705             !vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx)))
 706                 return 0;
 707
 708         ret = v4l2_m2m_ioctl_encoder_cmd(file, priv, ec);
 709         if (ret < 0)
 710                 return ret;
 711
 712         if (ec->cmd == V4L2_ENC_CMD_STOP &&
 713             v4l2_m2m_has_stopped(ctx->fh.m2m_ctx))
 714                 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
 715
 716         if (ec->cmd == V4L2_ENC_CMD_START)
 717                 vb2_clear_last_buffer_dequeued(&ctx->fh.m2m_ctx->cap_q_ctx.q);
 718
 719         return 0;
 720 }
 721
 722 const struct v4l2_ioctl_ops hantro_ioctl_ops = {
 723         .vidioc_querycap = vidioc_querycap,
 724         .vidioc_enum_framesizes = vidioc_enum_framesizes,
 725
 726         .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_cap_mplane,
 727         .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_out_mplane,
 728         .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_out_mplane,
 729         .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_cap_mplane,
 730         .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_out_mplane,
 731         .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_cap_mplane,
 732         .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
 733         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
 734
 735         .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
 736         .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
 737         .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
 738         .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
 739         .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
 740         .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
 741         .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
 742
 743         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 744         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 745
 746         .vidioc_streamon = v4l2_m2m_ioctl_streamon,
 747         .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
 748
 749         .vidioc_g_selection = vidioc_g_selection,
 750         .vidioc_s_selection = vidioc_s_selection,
 751
 752         .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd,
 753         .vidioc_encoder_cmd = vidioc_encoder_cmd,
 754 };
 755
 756 static int
 757 hantro_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
 758                    unsigned int *num_planes, unsigned int sizes[],
 759                    struct device *alloc_devs[])
 760 {
 761         struct hantro_ctx *ctx = vb2_get_drv_priv(vq);
 762         struct v4l2_pix_format_mplane *pixfmt;
 763         int i;
 764
 765         switch (vq->type) {
 766         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 767                 pixfmt = &ctx->dst_fmt;
 768                 break;
 769         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 770                 pixfmt = &ctx->src_fmt;
 771                 break;
 772         default:
 773                 vpu_err("invalid queue type: %d\n", vq->type);
 774                 return -EINVAL;
 775         }
 776
 777         if (*num_planes) {
 778                 if (*num_planes != pixfmt->num_planes)
 779                         return -EINVAL;
 780                 for (i = 0; i < pixfmt->num_planes; ++i)
 781                         if (sizes[i] < pixfmt->plane_fmt[i].sizeimage)
 782                                 return -EINVAL;
 783                 return 0;
 784         }
 785
 786         *num_planes = pixfmt->num_planes;
 787         for (i = 0; i < pixfmt->num_planes; ++i)
 788                 sizes[i] = pixfmt->plane_fmt[i].sizeimage;
 789         return 0;
 790 }
 791
 792 static int
 793 hantro_buf_plane_check(struct vb2_buffer *vb,
 794                        struct v4l2_pix_format_mplane *pixfmt)
 795 {
 796         unsigned int sz;
 797         int i;
 798
 799         for (i = 0; i < pixfmt->num_planes; ++i) {
 800                 sz = pixfmt->plane_fmt[i].sizeimage;
 801                 vpu_debug(4, "plane %d size: %ld, sizeimage: %u\n",
 802                           i, vb2_plane_size(vb, i), sz);
 803                 if (vb2_plane_size(vb, i) < sz) {
 804                         vpu_err("plane %d is too small for output\n", i);
 805                         return -EINVAL;
 806                 }
 807         }
 808         return 0;
 809 }
 810
 811 static int hantro_buf_prepare(struct vb2_buffer *vb)
 812 {
 813         struct vb2_queue *vq = vb->vb2_queue;
 814         struct hantro_ctx *ctx = vb2_get_drv_priv(vq);
 815         struct v4l2_pix_format_mplane *pix_fmt;
 816         int ret;
 817
 818         if (V4L2_TYPE_IS_OUTPUT(vq->type))
 819                 pix_fmt = &ctx->src_fmt;
 820         else
 821                 pix_fmt = &ctx->dst_fmt;
 822         ret = hantro_buf_plane_check(vb, pix_fmt);
 823         if (ret)
 824                 return ret;
 825         /*
 826          * Buffer's bytesused must be written by driver for CAPTURE buffers.
 827          * (for OUTPUT buffers, if userspace passes 0 bytesused, v4l2-core sets
 828          * it to buffer length).
 829          */
 830         if (V4L2_TYPE_IS_CAPTURE(vq->type)) {
 831                 if (ctx->is_encoder)
 832                         vb2_set_plane_payload(vb, 0, 0);
 833                 else
 834                         vb2_set_plane_payload(vb, 0, pix_fmt->plane_fmt[0].sizeimage);
 835         }
 836
 837         return 0;
 838 }
 839
 840 static void hantro_buf_queue(struct vb2_buffer *vb)
 841 {
 842         struct hantro_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 843         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 844
 845         if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) &&
 846             vb2_is_streaming(vb->vb2_queue) &&
 847             v4l2_m2m_dst_buf_is_last(ctx->fh.m2m_ctx)) {
 848                 unsigned int i;
 849
 850                 for (i = 0; i < vb->num_planes; i++)
 851                         vb2_set_plane_payload(vb, i, 0);
 852
 853                 vbuf->field = V4L2_FIELD_NONE;
 854                 vbuf->sequence = ctx->sequence_cap++;
 855
 856                 v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, vbuf);
 857                 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
 858                 return;
 859         }
 860
 861         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
 862 }
 863
 864 static bool hantro_vq_is_coded(struct vb2_queue *q)
 865 {
 866         struct hantro_ctx *ctx = vb2_get_drv_priv(q);
 867
 868         return ctx->is_encoder != V4L2_TYPE_IS_OUTPUT(q->type);
 869 }
 870
 871 static int hantro_start_streaming(struct vb2_queue *q, unsigned int count)
 872 {
 873         struct hantro_ctx *ctx = vb2_get_drv_priv(q);
 874         int ret = 0;
 875
 876         v4l2_m2m_update_start_streaming_state(ctx->fh.m2m_ctx, q);
 877
 878         if (V4L2_TYPE_IS_OUTPUT(q->type))
 879                 ctx->sequence_out = 0;
 880         else
 881                 ctx->sequence_cap = 0;
 882
 883         if (hantro_vq_is_coded(q)) {
 884                 enum hantro_codec_mode codec_mode;
 885
 886                 if (V4L2_TYPE_IS_OUTPUT(q->type))
 887                         codec_mode = ctx->vpu_src_fmt->codec_mode;
 888                 else
 889                         codec_mode = ctx->vpu_dst_fmt->codec_mode;
 890
 891                 vpu_debug(4, "Codec mode = %d\n", codec_mode);
 892                 ctx->codec_ops = &ctx->dev->variant->codec_ops[codec_mode];
 893                 if (ctx->codec_ops->init) {
 894                         ret = ctx->codec_ops->init(ctx);
 895                         if (ret)
 896                                 return ret;
 897                 }
 898
 899                 if (hantro_needs_postproc(ctx, ctx->vpu_dst_fmt)) {
 900                         ret = hantro_postproc_alloc(ctx);
 901                         if (ret)
 902                                 goto err_codec_exit;
 903                 }
 904         }
 905         return ret;
 906
 907 err_codec_exit:
 908         if (ctx->codec_ops->exit)
 909                 ctx->codec_ops->exit(ctx);
 910         return ret;
 911 }
 912
 913 static void
 914 hantro_return_bufs(struct vb2_queue *q,
 915                    struct vb2_v4l2_buffer *(*buf_remove)(struct v4l2_m2m_ctx *))
 916 {
 917         struct hantro_ctx *ctx = vb2_get_drv_priv(q);
 918
 919         for (;;) {
 920                 struct vb2_v4l2_buffer *vbuf;
 921
 922                 vbuf = buf_remove(ctx->fh.m2m_ctx);
 923                 if (!vbuf)
 924                         break;
 925                 v4l2_ctrl_request_complete(vbuf->vb2_buf.req_obj.req,
 926                                            &ctx->ctrl_handler);
 927                 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
 928         }
 929 }
 930
 931 static void hantro_stop_streaming(struct vb2_queue *q)
 932 {
 933         struct hantro_ctx *ctx = vb2_get_drv_priv(q);
 934
 935         if (hantro_vq_is_coded(q)) {
 936                 hantro_postproc_free(ctx);
 937                 if (ctx->codec_ops && ctx->codec_ops->exit)
 938                         ctx->codec_ops->exit(ctx);
 939         }
 940
 941         /*
 942          * The mem2mem framework calls v4l2_m2m_cancel_job before
 943          * .stop_streaming, so there isn't any job running and
 944          * it is safe to return all the buffers.
 945          */
 946         if (V4L2_TYPE_IS_OUTPUT(q->type))
 947                 hantro_return_bufs(q, v4l2_m2m_src_buf_remove);
 948         else
 949                 hantro_return_bufs(q, v4l2_m2m_dst_buf_remove);
 950
 951         v4l2_m2m_update_stop_streaming_state(ctx->fh.m2m_ctx, q);
 952
 953         if (V4L2_TYPE_IS_OUTPUT(q->type) &&
 954             v4l2_m2m_has_stopped(ctx->fh.m2m_ctx))
 955                 v4l2_event_queue_fh(&ctx->fh, &hantro_eos_event);
 956 }
 957
 958 static void hantro_buf_request_complete(struct vb2_buffer *vb)
 959 {
 960         struct hantro_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 961
 962         v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->ctrl_handler);
 963 }
 964
 965 static int hantro_buf_out_validate(struct vb2_buffer *vb)
 966 {
 967         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 968
 969         vbuf->field = V4L2_FIELD_NONE;
 970         return 0;
 971 }
 972
 973 const struct vb2_ops hantro_queue_ops = {
 974         .queue_setup = hantro_queue_setup,
 975         .buf_prepare = hantro_buf_prepare,
 976         .buf_queue = hantro_buf_queue,
 977         .buf_out_validate = hantro_buf_out_validate,
 978         .buf_request_complete = hantro_buf_request_complete,
 979         .start_streaming = hantro_start_streaming,
 980         .stop_streaming = hantro_stop_streaming,
 981         .wait_prepare = vb2_ops_wait_prepare,
 982         .wait_finish = vb2_ops_wait_finish,
 983 };