drivers/media/platform/amphion/venc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2020-2021 NXP
   4  */
   5
   6 #include <linux/init.h>
   7 #include <linux/interconnect.h>
   8 #include <linux/ioctl.h>
   9 #include <linux/list.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/delay.h>
  13 #include <linux/videodev2.h>
  14 #include <linux/ktime.h>
  15 #include <linux/rational.h>
  16 #include <linux/vmalloc.h>
  17 #include <media/v4l2-device.h>
  18 #include <media/v4l2-event.h>
  19 #include <media/v4l2-mem2mem.h>
  20 #include <media/v4l2-ioctl.h>
  21 #include <media/videobuf2-v4l2.h>
  22 #include <media/videobuf2-dma-contig.h>
  23 #include <media/videobuf2-vmalloc.h>
  24 #include "vpu.h"
  25 #include "vpu_defs.h"
  26 #include "vpu_core.h"
  27 #include "vpu_helpers.h"
  28 #include "vpu_v4l2.h"
  29 #include "vpu_cmds.h"
  30 #include "vpu_rpc.h"
  31
  32 #define VENC_OUTPUT_ENABLE      BIT(0)
  33 #define VENC_CAPTURE_ENABLE     BIT(1)
  34 #define VENC_ENABLE_MASK        (VENC_OUTPUT_ENABLE | VENC_CAPTURE_ENABLE)
  35 #define VENC_MAX_BUF_CNT        8
  36 #define VENC_MIN_BUFFER_OUT     6
  37 #define VENC_MIN_BUFFER_CAP     6
  38
  39 struct venc_t {
  40         struct vpu_encode_params params;
  41         u32 request_key_frame;
  42         u32 input_ready;
  43         u32 cpb_size;
  44         bool bitrate_change;
  45
  46         struct vpu_buffer enc[VENC_MAX_BUF_CNT];
  47         struct vpu_buffer ref[VENC_MAX_BUF_CNT];
  48         struct vpu_buffer act[VENC_MAX_BUF_CNT];
  49         struct list_head frames;
  50         u32 frame_count;
  51         u32 encode_count;
  52         u32 ready_count;
  53         u32 enable;
  54         u32 stopped;
  55         u32 memory_resource_configured;
  56
  57         u32 skipped_count;
  58         u32 skipped_bytes;
  59
  60         wait_queue_head_t wq;
  61 };
  62
  63 struct venc_frame_t {
  64         struct list_head list;
  65         struct vpu_enc_pic_info info;
  66         u32 bytesused;
  67         s64 timestamp;
  68 };
  69
  70 static const struct vpu_format venc_formats[] = {
  71         {
  72                 .pixfmt = V4L2_PIX_FMT_NV12M,
  73                 .mem_planes = 2,
  74                 .comp_planes = 2,
  75                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
  76                 .sibling = V4L2_PIX_FMT_NV12,
  77         },
  78         {
  79                 .pixfmt = V4L2_PIX_FMT_NV12,
  80                 .mem_planes = 1,
  81                 .comp_planes = 2,
  82                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
  83                 .sibling = V4L2_PIX_FMT_NV12M,
  84         },
  85         {
  86                 .pixfmt = V4L2_PIX_FMT_H264,
  87                 .mem_planes = 1,
  88                 .comp_planes = 1,
  89                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
  90                 .flags = V4L2_FMT_FLAG_COMPRESSED
  91         },
  92         {0, 0, 0, 0},
  93 };
  94
  95 static int venc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
  96 {
  97         strscpy(cap->driver, "amphion-vpu", sizeof(cap->driver));
  98         strscpy(cap->card, "amphion vpu encoder", sizeof(cap->card));
  99         strscpy(cap->bus_info, "platform: amphion-vpu", sizeof(cap->bus_info));
 100
 101         return 0;
 102 }
 103
 104 static int venc_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
 105 {
 106         struct vpu_inst *inst = to_inst(file);
 107         const struct vpu_format *fmt;
 108
 109         memset(f->reserved, 0, sizeof(f->reserved));
 110         fmt = vpu_helper_enum_format(inst, f->type, f->index);
 111         if (!fmt)
 112                 return -EINVAL;
 113
 114         f->pixelformat = fmt->pixfmt;
 115         f->flags = fmt->flags;
 116
 117         return 0;
 118 }
 119
 120 static int venc_enum_framesizes(struct file *file, void *fh, struct v4l2_frmsizeenum *fsize)
 121 {
 122         struct vpu_inst *inst = to_inst(file);
 123         const struct vpu_core_resources *res;
 124
 125         if (!fsize || fsize->index)
 126                 return -EINVAL;
 127
 128         if (!vpu_helper_find_format(inst, 0, fsize->pixel_format))
 129                 return -EINVAL;
 130
 131         res = vpu_get_resource(inst);
 132         if (!res)
 133                 return -EINVAL;
 134         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
 135         fsize->stepwise.max_width = res->max_width;
 136         fsize->stepwise.max_height = res->max_height;
 137         fsize->stepwise.min_width = res->min_width;
 138         fsize->stepwise.min_height = res->min_height;
 139         fsize->stepwise.step_width = res->step_width;
 140         fsize->stepwise.step_height = res->step_height;
 141
 142         return 0;
 143 }
 144
 145 static int venc_enum_frameintervals(struct file *file, void *fh, struct v4l2_frmivalenum *fival)
 146 {
 147         struct vpu_inst *inst = to_inst(file);
 148         const struct vpu_core_resources *res;
 149
 150         if (!fival || fival->index)
 151                 return -EINVAL;
 152
 153         if (!vpu_helper_find_format(inst, 0, fival->pixel_format))
 154                 return -EINVAL;
 155
 156         if (!fival->width || !fival->height)
 157                 return -EINVAL;
 158
 159         res = vpu_get_resource(inst);
 160         if (!res)
 161                 return -EINVAL;
 162         if (fival->width < res->min_width || fival->width > res->max_width ||
 163             fival->height < res->min_height || fival->height > res->max_height)
 164                 return -EINVAL;
 165
 166         fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
 167         fival->stepwise.min.numerator = 1;
 168         fival->stepwise.min.denominator = USHRT_MAX;
 169         fival->stepwise.max.numerator = USHRT_MAX;
 170         fival->stepwise.max.denominator = 1;
 171         fival->stepwise.step.numerator = 1;
 172         fival->stepwise.step.denominator = 1;
 173
 174         return 0;
 175 }
 176
 177 static int venc_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
 178 {
 179         struct vpu_inst *inst = to_inst(file);
 180         struct venc_t *venc = inst->priv;
 181         struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
 182         struct vpu_format *cur_fmt;
 183         int i;
 184
 185         cur_fmt = vpu_get_format(inst, f->type);
 186
 187         pixmp->pixelformat = cur_fmt->pixfmt;
 188         pixmp->num_planes = cur_fmt->mem_planes;
 189         pixmp->width = cur_fmt->width;
 190         pixmp->height = cur_fmt->height;
 191         pixmp->field = cur_fmt->field;
 192         pixmp->flags = cur_fmt->flags;
 193         for (i = 0; i < pixmp->num_planes; i++) {
 194                 pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
 195                 pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
 196         }
 197
 198         f->fmt.pix_mp.colorspace = venc->params.color.primaries;
 199         f->fmt.pix_mp.xfer_func = venc->params.color.transfer;
 200         f->fmt.pix_mp.ycbcr_enc = venc->params.color.matrix;
 201         f->fmt.pix_mp.quantization = venc->params.color.full_range;
 202
 203         return 0;
 204 }
 205
 206 static int venc_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
 207 {
 208         struct vpu_inst *inst = to_inst(file);
 209         struct vpu_format fmt;
 210
 211         vpu_try_fmt_common(inst, f, &fmt);
 212
 213         return 0;
 214 }
 215
 216 static int venc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
 217 {
 218         struct vpu_inst *inst = to_inst(file);
 219         struct vpu_format fmt;
 220         struct vpu_format *cur_fmt;
 221         struct vb2_queue *q;
 222         struct venc_t *venc = inst->priv;
 223         struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
 224
 225         q = v4l2_m2m_get_vq(inst->fh.m2m_ctx, f->type);
 226         if (!q)
 227                 return -EINVAL;
 228         if (vb2_is_busy(q))
 229                 return -EBUSY;
 230
 231         if (vpu_try_fmt_common(inst, f, &fmt))
 232                 return -EINVAL;
 233
 234         cur_fmt = vpu_get_format(inst, f->type);
 235
 236         memcpy(cur_fmt, &fmt, sizeof(*cur_fmt));
 237
 238         if (V4L2_TYPE_IS_OUTPUT(f->type)) {
 239                 venc->params.input_format = cur_fmt->pixfmt;
 240                 venc->params.src_stride = cur_fmt->bytesperline[0];
 241                 venc->params.src_width = cur_fmt->width;
 242                 venc->params.src_height = cur_fmt->height;
 243                 venc->params.crop.left = 0;
 244                 venc->params.crop.top = 0;
 245                 venc->params.crop.width = cur_fmt->width;
 246                 venc->params.crop.height = cur_fmt->height;
 247         } else {
 248                 venc->params.codec_format = cur_fmt->pixfmt;
 249                 venc->params.out_width = cur_fmt->width;
 250                 venc->params.out_height = cur_fmt->height;
 251         }
 252
 253         if (V4L2_TYPE_IS_OUTPUT(f->type)) {
 254                 venc->params.color.primaries = pix_mp->colorspace;
 255                 venc->params.color.transfer = pix_mp->xfer_func;
 256                 venc->params.color.matrix = pix_mp->ycbcr_enc;
 257                 venc->params.color.full_range = pix_mp->quantization;
 258         }
 259
 260         pix_mp->colorspace = venc->params.color.primaries;
 261         pix_mp->xfer_func = venc->params.color.transfer;
 262         pix_mp->ycbcr_enc = venc->params.color.matrix;
 263         pix_mp->quantization = venc->params.color.full_range;
 264
 265         return 0;
 266 }
 267
 268 static int venc_g_parm(struct file *file, void *fh, struct v4l2_streamparm *parm)
 269 {
 270         struct vpu_inst *inst = to_inst(file);
 271         struct venc_t *venc = inst->priv;
 272         struct v4l2_fract *timeperframe;
 273
 274         if (!parm)
 275                 return -EINVAL;
 276
 277         if (!V4L2_TYPE_IS_OUTPUT(parm->type))
 278                 return -EINVAL;
 279
 280         if (!vpu_helper_check_type(inst, parm->type))
 281                 return -EINVAL;
 282
 283         timeperframe = &parm->parm.capture.timeperframe;
 284         parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 285         parm->parm.capture.readbuffers = 0;
 286         timeperframe->numerator = venc->params.frame_rate.numerator;
 287         timeperframe->denominator = venc->params.frame_rate.denominator;
 288
 289         return 0;
 290 }
 291
 292 static int venc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *parm)
 293 {
 294         struct vpu_inst *inst = to_inst(file);
 295         struct venc_t *venc = inst->priv;
 296         struct v4l2_fract *timeperframe;
 297         unsigned long n, d;
 298
 299         if (!parm)
 300                 return -EINVAL;
 301
 302         if (!V4L2_TYPE_IS_OUTPUT(parm->type))
 303                 return -EINVAL;
 304
 305         if (!vpu_helper_check_type(inst, parm->type))
 306                 return -EINVAL;
 307
 308         timeperframe = &parm->parm.capture.timeperframe;
 309         if (!timeperframe->numerator)
 310                 timeperframe->numerator = venc->params.frame_rate.numerator;
 311         if (!timeperframe->denominator)
 312                 timeperframe->denominator = venc->params.frame_rate.denominator;
 313
 314         venc->params.frame_rate.numerator = timeperframe->numerator;
 315         venc->params.frame_rate.denominator = timeperframe->denominator;
 316
 317         rational_best_approximation(venc->params.frame_rate.numerator,
 318                                     venc->params.frame_rate.denominator,
 319                                     venc->params.frame_rate.numerator,
 320                                     venc->params.frame_rate.denominator,
 321                                     &n, &d);
 322         venc->params.frame_rate.numerator = n;
 323         venc->params.frame_rate.denominator = d;
 324
 325         parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 326         memset(parm->parm.capture.reserved, 0, sizeof(parm->parm.capture.reserved));
 327
 328         return 0;
 329 }
 330
 331 static int venc_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
 332 {
 333         struct vpu_inst *inst = to_inst(file);
 334         struct venc_t *venc = inst->priv;
 335
 336         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 337                 return -EINVAL;
 338
 339         switch (s->target) {
 340         case V4L2_SEL_TGT_CROP_DEFAULT:
 341         case V4L2_SEL_TGT_CROP_BOUNDS:
 342                 s->r.left = 0;
 343                 s->r.top = 0;
 344                 s->r.width = inst->out_format.width;
 345                 s->r.height = inst->out_format.height;
 346                 break;
 347         case V4L2_SEL_TGT_CROP:
 348                 s->r = venc->params.crop;
 349                 break;
 350         default:
 351                 return -EINVAL;
 352         }
 353
 354         return 0;
 355 }
 356
 357 static int venc_valid_crop(struct venc_t *venc, const struct vpu_core_resources *res)
 358 {
 359         struct v4l2_rect *rect = NULL;
 360         u32 min_width;
 361         u32 min_height;
 362         u32 src_width;
 363         u32 src_height;
 364
 365         rect = &venc->params.crop;
 366         min_width = res->min_width;
 367         min_height = res->min_height;
 368         src_width = venc->params.src_width;
 369         src_height = venc->params.src_height;
 370
 371         if (rect->width == 0 || rect->height == 0)
 372                 return -EINVAL;
 373         if (rect->left > src_width - min_width || rect->top > src_height - min_height)
 374                 return -EINVAL;
 375
 376         rect->width = min(rect->width, src_width - rect->left);
 377         rect->width = max_t(u32, rect->width, min_width);
 378
 379         rect->height = min(rect->height, src_height - rect->top);
 380         rect->height = max_t(u32, rect->height, min_height);
 381
 382         return 0;
 383 }
 384
 385 static int venc_s_selection(struct file *file, void *fh, struct v4l2_selection *s)
 386 {
 387         struct vpu_inst *inst = to_inst(file);
 388         const struct vpu_core_resources *res;
 389         struct venc_t *venc = inst->priv;
 390
 391         res = vpu_get_resource(inst);
 392         if (!res)
 393                 return -EINVAL;
 394
 395         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 396                 return -EINVAL;
 397         if (s->target != V4L2_SEL_TGT_CROP)
 398                 return -EINVAL;
 399
 400         venc->params.crop.left = ALIGN(s->r.left, res->step_width);
 401         venc->params.crop.top = ALIGN(s->r.top, res->step_height);
 402         venc->params.crop.width = ALIGN(s->r.width, res->step_width);
 403         venc->params.crop.height = ALIGN(s->r.height, res->step_height);
 404         if (venc_valid_crop(venc, res)) {
 405                 venc->params.crop.left = 0;
 406                 venc->params.crop.top = 0;
 407                 venc->params.crop.width = venc->params.src_width;
 408                 venc->params.crop.height = venc->params.src_height;
 409         }
 410
 411         inst->crop = venc->params.crop;
 412
 413         return 0;
 414 }
 415
 416 static int venc_drain(struct vpu_inst *inst)
 417 {
 418         struct venc_t *venc = inst->priv;
 419         int ret;
 420
 421         if (!inst->fh.m2m_ctx)
 422                 return 0;
 423
 424         if (inst->state != VPU_CODEC_STATE_DRAIN)
 425                 return 0;
 426
 427         if (!vpu_is_source_empty(inst))
 428                 return 0;
 429
 430         if (!venc->input_ready)
 431                 return 0;
 432
 433         venc->input_ready = false;
 434         vpu_trace(inst->dev, "[%d]\n", inst->id);
 435         ret = vpu_session_stop(inst);
 436         if (ret)
 437                 return ret;
 438         inst->state = VPU_CODEC_STATE_STOP;
 439         wake_up_all(&venc->wq);
 440
 441         return 0;
 442 }
 443
 444 static int venc_request_eos(struct vpu_inst *inst)
 445 {
 446         inst->state = VPU_CODEC_STATE_DRAIN;
 447         venc_drain(inst);
 448
 449         return 0;
 450 }
 451
 452 static int venc_encoder_cmd(struct file *file, void *fh, struct v4l2_encoder_cmd *cmd)
 453 {
 454         struct vpu_inst *inst = to_inst(file);
 455         int ret;
 456
 457         ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, cmd);
 458         if (ret)
 459                 return ret;
 460
 461         vpu_inst_lock(inst);
 462         if (cmd->cmd == V4L2_ENC_CMD_STOP) {
 463                 if (inst->state == VPU_CODEC_STATE_DEINIT)
 464                         vpu_set_last_buffer_dequeued(inst, true);
 465                 else
 466                         venc_request_eos(inst);
 467         }
 468         vpu_inst_unlock(inst);
 469
 470         return 0;
 471 }
 472
 473 static int venc_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
 474 {
 475         switch (sub->type) {
 476         case V4L2_EVENT_EOS:
 477                 return v4l2_event_subscribe(fh, sub, 0, NULL);
 478         case V4L2_EVENT_CTRL:
 479                 return v4l2_ctrl_subscribe_event(fh, sub);
 480         default:
 481                 return -EINVAL;
 482         }
 483 }
 484
 485 static const struct v4l2_ioctl_ops venc_ioctl_ops = {
 486         .vidioc_querycap               = venc_querycap,
 487         .vidioc_enum_fmt_vid_cap       = venc_enum_fmt,
 488         .vidioc_enum_fmt_vid_out       = venc_enum_fmt,
 489         .vidioc_enum_framesizes        = venc_enum_framesizes,
 490         .vidioc_enum_frameintervals    = venc_enum_frameintervals,
 491         .vidioc_g_fmt_vid_cap_mplane   = venc_g_fmt,
 492         .vidioc_g_fmt_vid_out_mplane   = venc_g_fmt,
 493         .vidioc_try_fmt_vid_cap_mplane = venc_try_fmt,
 494         .vidioc_try_fmt_vid_out_mplane = venc_try_fmt,
 495         .vidioc_s_fmt_vid_cap_mplane   = venc_s_fmt,
 496         .vidioc_s_fmt_vid_out_mplane   = venc_s_fmt,
 497         .vidioc_g_parm                 = venc_g_parm,
 498         .vidioc_s_parm                 = venc_s_parm,
 499         .vidioc_g_selection            = venc_g_selection,
 500         .vidioc_s_selection            = venc_s_selection,
 501         .vidioc_try_encoder_cmd        = v4l2_m2m_ioctl_try_encoder_cmd,
 502         .vidioc_encoder_cmd            = venc_encoder_cmd,
 503         .vidioc_subscribe_event        = venc_subscribe_event,
 504         .vidioc_unsubscribe_event      = v4l2_event_unsubscribe,
 505         .vidioc_reqbufs                = v4l2_m2m_ioctl_reqbufs,
 506         .vidioc_querybuf               = v4l2_m2m_ioctl_querybuf,
 507         .vidioc_create_bufs            = v4l2_m2m_ioctl_create_bufs,
 508         .vidioc_prepare_buf            = v4l2_m2m_ioctl_prepare_buf,
 509         .vidioc_qbuf                   = v4l2_m2m_ioctl_qbuf,
 510         .vidioc_expbuf                 = v4l2_m2m_ioctl_expbuf,
 511         .vidioc_dqbuf                  = v4l2_m2m_ioctl_dqbuf,
 512         .vidioc_streamon               = v4l2_m2m_ioctl_streamon,
 513         .vidioc_streamoff              = v4l2_m2m_ioctl_streamoff,
 514 };
 515
 516 static int venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
 517 {
 518         struct vpu_inst *inst = ctrl_to_inst(ctrl);
 519         struct venc_t *venc = inst->priv;
 520         int ret = 0;
 521
 522         switch (ctrl->id) {
 523         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
 524                 venc->params.profile = ctrl->val;
 525                 break;
 526         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
 527                 venc->params.level = ctrl->val;
 528                 break;
 529         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
 530                 venc->params.rc_enable = ctrl->val;
 531                 break;
 532         case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 533                 venc->params.rc_mode = ctrl->val;
 534                 break;
 535         case V4L2_CID_MPEG_VIDEO_BITRATE:
 536                 if (ctrl->val != venc->params.bitrate)
 537                         venc->bitrate_change = true;
 538                 venc->params.bitrate = ctrl->val;
 539                 break;
 540         case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 541                 venc->params.bitrate_max = ctrl->val;
 542                 break;
 543         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
 544                 venc->params.gop_length = ctrl->val;
 545                 break;
 546         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 547                 venc->params.bframes = ctrl->val;
 548                 break;
 549         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
 550                 venc->params.i_frame_qp = ctrl->val;
 551                 break;
 552         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
 553                 venc->params.p_frame_qp = ctrl->val;
 554                 break;
 555         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
 556                 venc->params.b_frame_qp = ctrl->val;
 557                 break;
 558         case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
 559                 venc->request_key_frame = 1;
 560                 break;
 561         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
 562                 venc->cpb_size = ctrl->val * 1024;
 563                 break;
 564         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
 565                 venc->params.sar.enable = ctrl->val;
 566                 break;
 567         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
 568                 venc->params.sar.idc = ctrl->val;
 569                 break;
 570         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
 571                 venc->params.sar.width = ctrl->val;
 572                 break;
 573         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
 574                 venc->params.sar.height = ctrl->val;
 575                 break;
 576         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
 577                 break;
 578         default:
 579                 ret = -EINVAL;
 580                 break;
 581         }
 582
 583         return ret;
 584 }
 585
 586 static const struct v4l2_ctrl_ops venc_ctrl_ops = {
 587         .s_ctrl = venc_op_s_ctrl,
 588         .g_volatile_ctrl = vpu_helper_g_volatile_ctrl,
 589 };
 590
 591 static int venc_ctrl_init(struct vpu_inst *inst)
 592 {
 593         struct v4l2_ctrl *ctrl;
 594         int ret;
 595
 596         ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 20);
 597         if (ret)
 598                 return ret;
 599
 600         v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 601                                V4L2_CID_MPEG_VIDEO_H264_PROFILE,
 602                                V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
 603                                ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
 604                                  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
 605                                  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
 606                                V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);
 607
 608         v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 609                                V4L2_CID_MPEG_VIDEO_H264_LEVEL,
 610                                V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
 611                                0x0,
 612                                V4L2_MPEG_VIDEO_H264_LEVEL_4_0);
 613
 614         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 615                           V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);
 616
 617         v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 618                                V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
 619                                V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
 620                                ~((1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
 621                                  (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)),
 622                                V4L2_MPEG_VIDEO_BITRATE_MODE_CBR);
 623
 624         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 625                           V4L2_CID_MPEG_VIDEO_BITRATE,
 626                           BITRATE_MIN,
 627                           BITRATE_MAX,
 628                           BITRATE_STEP,
 629                           BITRATE_DEFAULT);
 630
 631         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 632                           V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
 633                           BITRATE_MIN, BITRATE_MAX,
 634                           BITRATE_STEP,
 635                           BITRATE_DEFAULT_PEAK);
 636
 637         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 638                           V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 8000, 1, 30);
 639
 640         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 641                           V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 4, 1, 0);
 642
 643         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 644                           V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 1, 51, 1, 26);
 645         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 646                           V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 1, 51, 1, 28);
 647         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 648                           V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP, 1, 51, 1, 30);
 649         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 650                           V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, 0, 0, 0, 0);
 651         ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 652                                  V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 32, 1, 2);
 653         if (ctrl)
 654                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 655         ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 656                                  V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 1, 32, 1, 2);
 657         if (ctrl)
 658                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 659
 660         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 661                           V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE, 64, 10240, 1, 1024);
 662
 663         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 664                           V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE, 0, 1, 1, 1);
 665         v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 666                                V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC,
 667                                V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED,
 668                                0x0,
 669                                V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1);
 670         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 671                           V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH,
 672                           0, USHRT_MAX, 1, 1);
 673         v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
 674                           V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT,
 675                           0, USHRT_MAX, 1, 1);
 676         v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
 677                                V4L2_CID_MPEG_VIDEO_HEADER_MODE,
 678                                V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
 679                                ~(1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME),
 680                                V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);
 681
 682         v4l2_ctrl_new_std(&inst->ctrl_handler, NULL,
 683                           V4L2_CID_MPEG_VIDEO_AVERAGE_QP, 0, 51, 1, 0);
 684
 685         if (inst->ctrl_handler.error) {
 686                 ret = inst->ctrl_handler.error;
 687                 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 688                 return ret;
 689         }
 690
 691         ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
 692         if (ret) {
 693                 dev_err(inst->dev, "[%d] setup ctrls fail, ret = %d\n", inst->id, ret);
 694                 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 695                 return ret;
 696         }
 697
 698         return 0;
 699 }
 700
 701 static bool venc_check_ready(struct vpu_inst *inst, unsigned int type)
 702 {
 703         struct venc_t *venc = inst->priv;
 704
 705         if (V4L2_TYPE_IS_OUTPUT(type)) {
 706                 if (vpu_helper_get_free_space(inst) < venc->cpb_size)
 707                         return false;
 708                 return venc->input_ready;
 709         }
 710
 711         if (list_empty(&venc->frames))
 712                 return false;
 713         return true;
 714 }
 715
 716 static u32 venc_get_enable_mask(u32 type)
 717 {
 718         if (V4L2_TYPE_IS_OUTPUT(type))
 719                 return VENC_OUTPUT_ENABLE;
 720         else
 721                 return VENC_CAPTURE_ENABLE;
 722 }
 723
 724 static void venc_set_enable(struct venc_t *venc, u32 type, int enable)
 725 {
 726         u32 mask = venc_get_enable_mask(type);
 727
 728         if (enable)
 729                 venc->enable |= mask;
 730         else
 731                 venc->enable &= ~mask;
 732 }
 733
 734 static u32 venc_get_enable(struct venc_t *venc, u32 type)
 735 {
 736         return venc->enable & venc_get_enable_mask(type);
 737 }
 738
 739 static void venc_input_done(struct vpu_inst *inst)
 740 {
 741         struct venc_t *venc = inst->priv;
 742
 743         vpu_inst_lock(inst);
 744         venc->input_ready = true;
 745         vpu_process_output_buffer(inst);
 746         if (inst->state == VPU_CODEC_STATE_DRAIN)
 747                 venc_drain(inst);
 748         vpu_inst_unlock(inst);
 749 }
 750
 751 /*
 752  * It's hardware limitation, that there may be several bytes
 753  * redundant data at the beginning of frame.
 754  * For android platform, the redundant data may cause cts test fail
 755  * So driver will strip them
 756  */
 757 static int venc_precheck_encoded_frame(struct vpu_inst *inst, struct venc_frame_t *frame)
 758 {
 759         struct venc_t *venc;
 760         int skipped;
 761
 762         if (!frame || !frame->bytesused)
 763                 return -EINVAL;
 764
 765         venc = inst->priv;
 766         skipped = vpu_helper_find_startcode(&inst->stream_buffer,
 767                                             inst->cap_format.pixfmt,
 768                                             frame->info.wptr - inst->stream_buffer.phys,
 769                                             frame->bytesused);
 770         if (skipped > 0) {
 771                 frame->bytesused -= skipped;
 772                 frame->info.wptr = vpu_helper_step_walk(&inst->stream_buffer,
 773                                                         frame->info.wptr, skipped);
 774                 venc->skipped_bytes += skipped;
 775                 venc->skipped_count++;
 776         }
 777
 778         return 0;
 779 }
 780
 781 static int venc_get_one_encoded_frame(struct vpu_inst *inst,
 782                                       struct venc_frame_t *frame,
 783                                       struct vb2_v4l2_buffer *vbuf)
 784 {
 785         struct venc_t *venc = inst->priv;
 786         struct vb2_v4l2_buffer *src_buf;
 787
 788         if (!vbuf)
 789                 return -EAGAIN;
 790
 791         src_buf = vpu_find_buf_by_sequence(inst, inst->out_format.type, frame->info.frame_id);
 792         if (src_buf) {
 793                 v4l2_m2m_buf_copy_metadata(src_buf, vbuf, true);
 794                 vpu_set_buffer_state(src_buf, VPU_BUF_STATE_IDLE);
 795                 v4l2_m2m_src_buf_remove_by_buf(inst->fh.m2m_ctx, src_buf);
 796                 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
 797         } else {
 798                 vbuf->vb2_buf.timestamp = frame->info.timestamp;
 799         }
 800         if (!venc_get_enable(inst->priv, vbuf->vb2_buf.type)) {
 801                 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
 802                 return 0;
 803         }
 804         if (frame->bytesused > vbuf->vb2_buf.planes[0].length) {
 805                 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
 806                 return -ENOMEM;
 807         }
 808
 809         venc_precheck_encoded_frame(inst, frame);
 810
 811         if (frame->bytesused) {
 812                 u32 rptr = frame->info.wptr;
 813                 void *dst = vb2_plane_vaddr(&vbuf->vb2_buf, 0);
 814
 815                 vpu_helper_copy_from_stream_buffer(&inst->stream_buffer,
 816                                                    &rptr, frame->bytesused, dst);
 817                 vpu_iface_update_stream_buffer(inst, rptr, 0);
 818         }
 819         vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->bytesused);
 820         vbuf->sequence = frame->info.frame_id;
 821         vbuf->field = inst->cap_format.field;
 822         vbuf->flags |= frame->info.pic_type;
 823         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_IDLE);
 824         vpu_set_buffer_average_qp(vbuf, frame->info.average_qp);
 825         dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
 826         v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
 827         venc->ready_count++;
 828
 829         if (vbuf->flags & V4L2_BUF_FLAG_KEYFRAME)
 830                 dev_dbg(inst->dev, "[%d][%d]key frame\n", inst->id, frame->info.frame_id);
 831
 832         return 0;
 833 }
 834
 835 static int venc_get_encoded_frames(struct vpu_inst *inst)
 836 {
 837         struct venc_t *venc;
 838         struct venc_frame_t *frame;
 839         struct venc_frame_t *tmp;
 840
 841         if (!inst->fh.m2m_ctx)
 842                 return 0;
 843         venc = inst->priv;
 844         list_for_each_entry_safe(frame, tmp, &venc->frames, list) {
 845                 if (venc_get_one_encoded_frame(inst, frame,
 846                                                v4l2_m2m_dst_buf_remove(inst->fh.m2m_ctx)))
 847                         break;
 848                 list_del_init(&frame->list);
 849                 vfree(frame);
 850         }
 851
 852         return 0;
 853 }
 854
 855 static int venc_frame_encoded(struct vpu_inst *inst, void *arg)
 856 {
 857         struct vpu_enc_pic_info *info = arg;
 858         struct venc_frame_t *frame;
 859         struct venc_t *venc;
 860         int ret = 0;
 861
 862         if (!info)
 863                 return -EINVAL;
 864         venc = inst->priv;
 865         frame = vzalloc(sizeof(*frame));
 866         if (!frame)
 867                 return -ENOMEM;
 868
 869         memcpy(&frame->info, info, sizeof(frame->info));
 870         frame->bytesused = info->frame_size;
 871
 872         vpu_inst_lock(inst);
 873         list_add_tail(&frame->list, &venc->frames);
 874         venc->encode_count++;
 875         venc_get_encoded_frames(inst);
 876         vpu_inst_unlock(inst);
 877
 878         return ret;
 879 }
 880
 881 static void venc_set_last_buffer_dequeued(struct vpu_inst *inst)
 882 {
 883         struct venc_t *venc = inst->priv;
 884
 885         if (venc->stopped && list_empty(&venc->frames))
 886                 vpu_set_last_buffer_dequeued(inst, true);
 887 }
 888
 889 static void venc_stop_done(struct vpu_inst *inst)
 890 {
 891         struct venc_t *venc = inst->priv;
 892
 893         vpu_inst_lock(inst);
 894         venc->stopped = true;
 895         venc_set_last_buffer_dequeued(inst);
 896         vpu_inst_unlock(inst);
 897
 898         wake_up_all(&venc->wq);
 899 }
 900
 901 static void venc_event_notify(struct vpu_inst *inst, u32 event, void *data)
 902 {
 903 }
 904
 905 static void venc_release(struct vpu_inst *inst)
 906 {
 907 }
 908
 909 static void venc_cleanup(struct vpu_inst *inst)
 910 {
 911         struct venc_t *venc;
 912
 913         if (!inst)
 914                 return;
 915
 916         venc = inst->priv;
 917         vfree(venc);
 918         inst->priv = NULL;
 919         vfree(inst);
 920 }
 921
 922 static int venc_start_session(struct vpu_inst *inst, u32 type)
 923 {
 924         struct venc_t *venc = inst->priv;
 925         int stream_buffer_size;
 926         int ret;
 927
 928         venc_set_enable(venc, type, 1);
 929         if ((venc->enable & VENC_ENABLE_MASK) != VENC_ENABLE_MASK)
 930                 return 0;
 931
 932         vpu_iface_init_instance(inst);
 933         stream_buffer_size = vpu_iface_get_stream_buffer_size(inst->core);
 934         if (stream_buffer_size > 0) {
 935                 inst->stream_buffer.length = max_t(u32, stream_buffer_size, venc->cpb_size * 3);
 936                 ret = vpu_alloc_dma(inst->core, &inst->stream_buffer);
 937                 if (ret)
 938                         goto error;
 939
 940                 inst->use_stream_buffer = true;
 941                 vpu_iface_config_stream_buffer(inst, &inst->stream_buffer);
 942         }
 943
 944         ret = vpu_iface_set_encode_params(inst, &venc->params, 0);
 945         if (ret)
 946                 goto error;
 947
 948         venc->memory_resource_configured = false;
 949         ret = vpu_session_configure_codec(inst);
 950         if (ret)
 951                 goto error;
 952
 953         if (!venc->memory_resource_configured) {
 954                 vb2_queue_error(v4l2_m2m_get_src_vq(inst->fh.m2m_ctx));
 955                 vb2_queue_error(v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx));
 956                 ret = -ENOMEM;
 957                 goto error;
 958         }
 959
 960         inst->state = VPU_CODEC_STATE_CONFIGURED;
 961         /*vpu_iface_config_memory_resource*/
 962
 963         /*config enc expert mode parameter*/
 964         ret = vpu_iface_set_encode_params(inst, &venc->params, 1);
 965         if (ret)
 966                 goto error;
 967
 968         ret = vpu_session_start(inst);
 969         if (ret)
 970                 goto error;
 971         inst->state = VPU_CODEC_STATE_STARTED;
 972
 973         venc->bitrate_change = false;
 974         venc->input_ready = true;
 975         venc->frame_count = 0;
 976         venc->encode_count = 0;
 977         venc->ready_count = 0;
 978         venc->stopped = false;
 979         vpu_process_output_buffer(inst);
 980         if (venc->frame_count == 0)
 981                 dev_err(inst->dev, "[%d] there is no input when starting\n", inst->id);
 982
 983         return 0;
 984 error:
 985         venc_set_enable(venc, type, 0);
 986         inst->state = VPU_CODEC_STATE_DEINIT;
 987
 988         vpu_free_dma(&inst->stream_buffer);
 989         return ret;
 990 }
 991
 992 static void venc_cleanup_mem_resource(struct vpu_inst *inst)
 993 {
 994         struct venc_t *venc;
 995         u32 i;
 996
 997         venc = inst->priv;
 998         venc->memory_resource_configured = false;
 999
1000         for (i = 0; i < ARRAY_SIZE(venc->enc); i++)
1001                 vpu_free_dma(&venc->enc[i]);
1002         for (i = 0; i < ARRAY_SIZE(venc->ref); i++)
1003                 vpu_free_dma(&venc->ref[i]);
1004 }
1005
1006 static void venc_request_mem_resource(struct vpu_inst *inst,
1007                                       u32 enc_frame_size,
1008                                       u32 enc_frame_num,
1009                                       u32 ref_frame_size,
1010                                       u32 ref_frame_num,
1011                                       u32 act_frame_size,
1012                                       u32 act_frame_num)
1013 {
1014         struct venc_t *venc;
1015         u32 i;
1016         int ret;
1017
1018         venc = inst->priv;
1019         if (enc_frame_num > ARRAY_SIZE(venc->enc)) {
1020                 dev_err(inst->dev, "[%d] enc num(%d) is out of range\n", inst->id, enc_frame_num);
1021                 return;
1022         }
1023         if (ref_frame_num > ARRAY_SIZE(venc->ref)) {
1024                 dev_err(inst->dev, "[%d] ref num(%d) is out of range\n", inst->id, ref_frame_num);
1025                 return;
1026         }
1027         if (act_frame_num > ARRAY_SIZE(venc->act)) {
1028                 dev_err(inst->dev, "[%d] act num(%d) is out of range\n", inst->id, act_frame_num);
1029                 return;
1030         }
1031
1032         for (i = 0; i < enc_frame_num; i++) {
1033                 venc->enc[i].length = enc_frame_size;
1034                 ret = vpu_alloc_dma(inst->core, &venc->enc[i]);
1035                 if (ret) {
1036                         venc_cleanup_mem_resource(inst);
1037                         return;
1038                 }
1039         }
1040         for (i = 0; i < ref_frame_num; i++) {
1041                 venc->ref[i].length = ref_frame_size;
1042                 ret = vpu_alloc_dma(inst->core, &venc->ref[i]);
1043                 if (ret) {
1044                         venc_cleanup_mem_resource(inst);
1045                         return;
1046                 }
1047         }
1048         if (act_frame_num != 1 || act_frame_size > inst->act.length) {
1049                 venc_cleanup_mem_resource(inst);
1050                 return;
1051         }
1052         venc->act[0].length = act_frame_size;
1053         venc->act[0].phys = inst->act.phys;
1054         venc->act[0].virt = inst->act.virt;
1055
1056         for (i = 0; i < enc_frame_num; i++)
1057                 vpu_iface_config_memory_resource(inst, MEM_RES_ENC, i, &venc->enc[i]);
1058         for (i = 0; i < ref_frame_num; i++)
1059                 vpu_iface_config_memory_resource(inst, MEM_RES_REF, i, &venc->ref[i]);
1060         for (i = 0; i < act_frame_num; i++)
1061                 vpu_iface_config_memory_resource(inst, MEM_RES_ACT, i, &venc->act[i]);
1062         venc->memory_resource_configured = true;
1063 }
1064
1065 static void venc_cleanup_frames(struct venc_t *venc)
1066 {
1067         struct venc_frame_t *frame;
1068         struct venc_frame_t *tmp;
1069
1070         list_for_each_entry_safe(frame, tmp, &venc->frames, list) {
1071                 list_del_init(&frame->list);
1072                 vfree(frame);
1073         }
1074 }
1075
1076 static int venc_stop_session(struct vpu_inst *inst, u32 type)
1077 {
1078         struct venc_t *venc = inst->priv;
1079
1080         venc_set_enable(venc, type, 0);
1081         if (venc->enable & VENC_ENABLE_MASK)
1082                 return 0;
1083
1084         if (inst->state == VPU_CODEC_STATE_DEINIT)
1085                 return 0;
1086
1087         if (inst->state != VPU_CODEC_STATE_STOP)
1088                 venc_request_eos(inst);
1089
1090         call_void_vop(inst, wait_prepare);
1091         if (!wait_event_timeout(venc->wq, venc->stopped, VPU_TIMEOUT)) {
1092                 set_bit(inst->id, &inst->core->hang_mask);
1093                 vpu_session_debug(inst);
1094         }
1095         call_void_vop(inst, wait_finish);
1096
1097         inst->state = VPU_CODEC_STATE_DEINIT;
1098         venc_cleanup_frames(inst->priv);
1099         vpu_free_dma(&inst->stream_buffer);
1100         venc_cleanup_mem_resource(inst);
1101
1102         return 0;
1103 }
1104
1105 static int venc_process_output(struct vpu_inst *inst, struct vb2_buffer *vb)
1106 {
1107         struct venc_t *venc = inst->priv;
1108         struct vb2_v4l2_buffer *vbuf;
1109         u32 flags;
1110
1111         if (inst->state == VPU_CODEC_STATE_DEINIT)
1112                 return -EINVAL;
1113
1114         vbuf = to_vb2_v4l2_buffer(vb);
1115         if (inst->state == VPU_CODEC_STATE_STARTED)
1116                 inst->state = VPU_CODEC_STATE_ACTIVE;
1117
1118         flags = vbuf->flags;
1119         if (venc->request_key_frame) {
1120                 vbuf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1121                 venc->request_key_frame = 0;
1122         }
1123         if (venc->bitrate_change) {
1124                 vpu_session_update_parameters(inst, &venc->params);
1125                 venc->bitrate_change = false;
1126         }
1127         dev_dbg(inst->dev, "[%d][INPUT  TS]%32lld\n", inst->id, vb->timestamp);
1128         vpu_iface_input_frame(inst, vb);
1129         vbuf->flags = flags;
1130         venc->input_ready = false;
1131         venc->frame_count++;
1132         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1133
1134         return 0;
1135 }
1136
1137 static int venc_process_capture(struct vpu_inst *inst, struct vb2_buffer *vb)
1138 {
1139         struct venc_t *venc;
1140         struct venc_frame_t *frame = NULL;
1141         struct vb2_v4l2_buffer *vbuf;
1142         int ret;
1143
1144         venc = inst->priv;
1145         if (list_empty(&venc->frames))
1146                 return -EINVAL;
1147
1148         frame = list_first_entry(&venc->frames, struct venc_frame_t, list);
1149         vbuf = to_vb2_v4l2_buffer(vb);
1150         v4l2_m2m_dst_buf_remove_by_buf(inst->fh.m2m_ctx, vbuf);
1151         ret = venc_get_one_encoded_frame(inst, frame, vbuf);
1152         if (ret)
1153                 return ret;
1154
1155         list_del_init(&frame->list);
1156         vfree(frame);
1157         return 0;
1158 }
1159
1160 static void venc_on_queue_empty(struct vpu_inst *inst, u32 type)
1161 {
1162         struct venc_t *venc = inst->priv;
1163
1164         if (V4L2_TYPE_IS_OUTPUT(type))
1165                 return;
1166
1167         if (venc->stopped)
1168                 venc_set_last_buffer_dequeued(inst);
1169 }
1170
1171 static int venc_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i)
1172 {
1173         struct venc_t *venc = inst->priv;
1174         int num = -1;
1175
1176         switch (i) {
1177         case 0:
1178                 num = scnprintf(str, size, "profile = %d\n", venc->params.profile);
1179                 break;
1180         case 1:
1181                 num = scnprintf(str, size, "level = %d\n", venc->params.level);
1182                 break;
1183         case 2:
1184                 num = scnprintf(str, size, "fps = %d/%d\n",
1185                                 venc->params.frame_rate.numerator,
1186                                 venc->params.frame_rate.denominator);
1187                 break;
1188         case 3:
1189                 num = scnprintf(str, size, "%d x %d -> %d x %d\n",
1190                                 venc->params.src_width,
1191                                 venc->params.src_height,
1192                                 venc->params.out_width,
1193                                 venc->params.out_height);
1194                 break;
1195         case 4:
1196                 num = scnprintf(str, size, "(%d, %d)  %d x %d\n",
1197                                 venc->params.crop.left,
1198                                 venc->params.crop.top,
1199                                 venc->params.crop.width,
1200                                 venc->params.crop.height);
1201                 break;
1202         case 5:
1203                 num = scnprintf(str, size,
1204                                 "enable = 0x%x, input = %d, encode = %d, ready = %d, stopped = %d\n",
1205                                 venc->enable,
1206                                 venc->frame_count, venc->encode_count,
1207                                 venc->ready_count,
1208                                 venc->stopped);
1209                 break;
1210         case 6:
1211                 num = scnprintf(str, size, "gop = %d\n", venc->params.gop_length);
1212                 break;
1213         case 7:
1214                 num = scnprintf(str, size, "bframes = %d\n", venc->params.bframes);
1215                 break;
1216         case 8:
1217                 num = scnprintf(str, size, "rc: %s, mode = %d, bitrate = %d(%d), qp = %d\n",
1218                                 venc->params.rc_enable ? "enable" : "disable",
1219                                 venc->params.rc_mode,
1220                                 venc->params.bitrate,
1221                                 venc->params.bitrate_max,
1222                                 venc->params.i_frame_qp);
1223                 break;
1224         case 9:
1225                 num = scnprintf(str, size, "sar: enable = %d, idc = %d, %d x %d\n",
1226                                 venc->params.sar.enable,
1227                                 venc->params.sar.idc,
1228                                 venc->params.sar.width,
1229                                 venc->params.sar.height);
1230
1231                 break;
1232         case 10:
1233                 num = scnprintf(str, size,
1234                                 "colorspace: primaries = %d, transfer = %d, matrix = %d, full_range = %d\n",
1235                                 venc->params.color.primaries,
1236                                 venc->params.color.transfer,
1237                                 venc->params.color.matrix,
1238                                 venc->params.color.full_range);
1239                 break;
1240         case 11:
1241                 num = scnprintf(str, size, "skipped: count = %d, bytes = %d\n",
1242                                 venc->skipped_count, venc->skipped_bytes);
1243                 break;
1244         default:
1245                 break;
1246         }
1247
1248         return num;
1249 }
1250
1251 static struct vpu_inst_ops venc_inst_ops = {
1252         .ctrl_init = venc_ctrl_init,
1253         .check_ready = venc_check_ready,
1254         .input_done = venc_input_done,
1255         .get_one_frame = venc_frame_encoded,
1256         .stop_done = venc_stop_done,
1257         .event_notify = venc_event_notify,
1258         .release = venc_release,
1259         .cleanup = venc_cleanup,
1260         .start = venc_start_session,
1261         .mem_request = venc_request_mem_resource,
1262         .stop = venc_stop_session,
1263         .process_output = venc_process_output,
1264         .process_capture = venc_process_capture,
1265         .on_queue_empty = venc_on_queue_empty,
1266         .get_debug_info = venc_get_debug_info,
1267         .wait_prepare = vpu_inst_unlock,
1268         .wait_finish = vpu_inst_lock,
1269 };
1270
1271 static void venc_init(struct file *file)
1272 {
1273         struct vpu_inst *inst = to_inst(file);
1274         struct venc_t *venc;
1275         struct v4l2_format f;
1276         struct v4l2_streamparm parm;
1277
1278         venc = inst->priv;
1279         venc->params.qp_min = 1;
1280         venc->params.qp_max = 51;
1281         venc->params.qp_min_i = 1;
1282         venc->params.qp_max_i = 51;
1283         venc->params.bitrate_min = BITRATE_MIN;
1284
1285         memset(&f, 0, sizeof(f));
1286         f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1287         f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;
1288         f.fmt.pix_mp.width = 1280;
1289         f.fmt.pix_mp.height = 720;
1290         f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1291         venc_s_fmt(file, &inst->fh, &f);
1292
1293         memset(&f, 0, sizeof(f));
1294         f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1295         f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
1296         f.fmt.pix_mp.width = 1280;
1297         f.fmt.pix_mp.height = 720;
1298         f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1299         venc_s_fmt(file, &inst->fh, &f);
1300
1301         memset(&parm, 0, sizeof(parm));
1302         parm.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1303         parm.parm.capture.timeperframe.numerator = 1;
1304         parm.parm.capture.timeperframe.denominator = 30;
1305         venc_s_parm(file, &inst->fh, &parm);
1306 }
1307
1308 static int venc_open(struct file *file)
1309 {
1310         struct vpu_inst *inst;
1311         struct venc_t *venc;
1312         int ret;
1313
1314         inst = vzalloc(sizeof(*inst));
1315         if (!inst)
1316                 return -ENOMEM;
1317
1318         venc = vzalloc(sizeof(*venc));
1319         if (!venc) {
1320                 vfree(inst);
1321                 return -ENOMEM;
1322         }
1323
1324         inst->ops = &venc_inst_ops;
1325         inst->formats = venc_formats;
1326         inst->type = VPU_CORE_TYPE_ENC;
1327         inst->priv = venc;
1328         INIT_LIST_HEAD(&venc->frames);
1329         init_waitqueue_head(&venc->wq);
1330
1331         ret = vpu_v4l2_open(file, inst);
1332         if (ret)
1333                 return ret;
1334
1335         inst->min_buffer_out = VENC_MIN_BUFFER_OUT;
1336         inst->min_buffer_cap = VENC_MIN_BUFFER_CAP;
1337         venc_init(file);
1338
1339         return 0;
1340 }
1341
1342 static const struct v4l2_file_operations venc_fops = {
1343         .owner = THIS_MODULE,
1344         .open = venc_open,
1345         .release = vpu_v4l2_close,
1346         .unlocked_ioctl = video_ioctl2,
1347         .poll = v4l2_m2m_fop_poll,
1348         .mmap = v4l2_m2m_fop_mmap,
1349 };
1350
1351 const struct v4l2_ioctl_ops *venc_get_ioctl_ops(void)
1352 {
1353         return &venc_ioctl_ops;
1354 }
1355
1356 const struct v4l2_file_operations *venc_get_fops(void)
1357 {
1358         return &venc_fops;
1359 }