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