drivers/media/platform/amphion/vdec.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/vmalloc.h>
  13 #include <linux/videodev2.h>
  14 #include <media/v4l2-device.h>
  15 #include <media/v4l2-event.h>
  16 #include <media/v4l2-mem2mem.h>
  17 #include <media/v4l2-ioctl.h>
  18 #include <media/videobuf2-v4l2.h>
  19 #include <media/videobuf2-dma-contig.h>
  20 #include <media/videobuf2-vmalloc.h>
  21 #include "vpu.h"
  22 #include "vpu_defs.h"
  23 #include "vpu_core.h"
  24 #include "vpu_helpers.h"
  25 #include "vpu_v4l2.h"
  26 #include "vpu_cmds.h"
  27 #include "vpu_rpc.h"
  28
  29 #define VDEC_MIN_BUFFER_CAP             8
  30 #define VDEC_MIN_BUFFER_OUT             8
  31
  32 struct vdec_fs_info {
  33         char name[8];
  34         u32 type;
  35         u32 max_count;
  36         u32 req_count;
  37         u32 count;
  38         u32 index;
  39         u32 size;
  40         struct vpu_buffer buffer[32];
  41         u32 tag;
  42 };
  43
  44 struct vdec_t {
  45         u32 seq_hdr_found;
  46         struct vpu_buffer udata;
  47         struct vpu_decode_params params;
  48         struct vpu_dec_codec_info codec_info;
  49         enum vpu_codec_state state;
  50
  51         struct vpu_vb2_buffer *slots[VB2_MAX_FRAME];
  52         u32 req_frame_count;
  53         struct vdec_fs_info mbi;
  54         struct vdec_fs_info dcp;
  55         u32 seq_tag;
  56
  57         bool reset_codec;
  58         bool fixed_fmt;
  59         u32 decoded_frame_count;
  60         u32 display_frame_count;
  61         u32 sequence;
  62         u32 eos_received;
  63         bool is_source_changed;
  64         u32 source_change;
  65         u32 drain;
  66         bool aborting;
  67 };
  68
  69 static const struct vpu_format vdec_formats[] = {
  70         {
  71                 .pixfmt = V4L2_PIX_FMT_NV12M_8L128,
  72                 .mem_planes = 2,
  73                 .comp_planes = 2,
  74                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
  75                 .sibling = V4L2_PIX_FMT_NV12_8L128,
  76         },
  77         {
  78                 .pixfmt = V4L2_PIX_FMT_NV12_8L128,
  79                 .mem_planes = 1,
  80                 .comp_planes = 2,
  81                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
  82                 .sibling = V4L2_PIX_FMT_NV12M_8L128,
  83         },
  84         {
  85                 .pixfmt = V4L2_PIX_FMT_NV12M_10BE_8L128,
  86                 .mem_planes = 2,
  87                 .comp_planes = 2,
  88                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
  89                 .sibling = V4L2_PIX_FMT_NV12_10BE_8L128,
  90         },
  91         {
  92                 .pixfmt = V4L2_PIX_FMT_NV12_10BE_8L128,
  93                 .mem_planes = 1,
  94                 .comp_planes = 2,
  95                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
  96                 .sibling = V4L2_PIX_FMT_NV12M_10BE_8L128
  97         },
  98         {
  99                 .pixfmt = V4L2_PIX_FMT_H264,
 100                 .mem_planes = 1,
 101                 .comp_planes = 1,
 102                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 103                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 104         },
 105         {
 106                 .pixfmt = V4L2_PIX_FMT_H264_MVC,
 107                 .mem_planes = 1,
 108                 .comp_planes = 1,
 109                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 110                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 111         },
 112         {
 113                 .pixfmt = V4L2_PIX_FMT_HEVC,
 114                 .mem_planes = 1,
 115                 .comp_planes = 1,
 116                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 117                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 118         },
 119         {
 120                 .pixfmt = V4L2_PIX_FMT_VC1_ANNEX_G,
 121                 .mem_planes = 1,
 122                 .comp_planes = 1,
 123                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 124                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 125         },
 126         {
 127                 .pixfmt = V4L2_PIX_FMT_VC1_ANNEX_L,
 128                 .mem_planes = 1,
 129                 .comp_planes = 1,
 130                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 131                 .flags = V4L2_FMT_FLAG_COMPRESSED
 132         },
 133         {
 134                 .pixfmt = V4L2_PIX_FMT_MPEG2,
 135                 .mem_planes = 1,
 136                 .comp_planes = 1,
 137                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 138                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 139         },
 140         {
 141                 .pixfmt = V4L2_PIX_FMT_MPEG4,
 142                 .mem_planes = 1,
 143                 .comp_planes = 1,
 144                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 145                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 146         },
 147         {
 148                 .pixfmt = V4L2_PIX_FMT_XVID,
 149                 .mem_planes = 1,
 150                 .comp_planes = 1,
 151                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 152                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 153         },
 154         {
 155                 .pixfmt = V4L2_PIX_FMT_VP8,
 156                 .mem_planes = 1,
 157                 .comp_planes = 1,
 158                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 159                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 160         },
 161         {
 162                 .pixfmt = V4L2_PIX_FMT_H263,
 163                 .mem_planes = 1,
 164                 .comp_planes = 1,
 165                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 166                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 167         },
 168         {
 169                 .pixfmt = V4L2_PIX_FMT_SPK,
 170                 .mem_planes = 1,
 171                 .comp_planes = 1,
 172                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 173                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 174         },
 175         {
 176                 .pixfmt = V4L2_PIX_FMT_RV30,
 177                 .mem_planes = 1,
 178                 .comp_planes = 1,
 179                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 180                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 181         },
 182         {
 183                 .pixfmt = V4L2_PIX_FMT_RV40,
 184                 .mem_planes = 1,
 185                 .comp_planes = 1,
 186                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
 187                 .flags = V4L2_FMT_FLAG_DYN_RESOLUTION | V4L2_FMT_FLAG_COMPRESSED
 188         },
 189         {0, 0, 0, 0},
 190 };
 191
 192 static int vdec_op_s_ctrl(struct v4l2_ctrl *ctrl)
 193 {
 194         struct vpu_inst *inst = ctrl_to_inst(ctrl);
 195         struct vdec_t *vdec = inst->priv;
 196         int ret = 0;
 197
 198         vpu_inst_lock(inst);
 199         switch (ctrl->id) {
 200         case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE:
 201                 vdec->params.display_delay_enable = ctrl->val;
 202                 break;
 203         case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY:
 204                 vdec->params.display_delay = ctrl->val;
 205                 break;
 206         default:
 207                 ret = -EINVAL;
 208                 break;
 209         }
 210         vpu_inst_unlock(inst);
 211
 212         return ret;
 213 }
 214
 215 static const struct v4l2_ctrl_ops vdec_ctrl_ops = {
 216         .s_ctrl = vdec_op_s_ctrl,
 217         .g_volatile_ctrl = vpu_helper_g_volatile_ctrl,
 218 };
 219
 220 static int vdec_ctrl_init(struct vpu_inst *inst)
 221 {
 222         struct v4l2_ctrl *ctrl;
 223         int ret;
 224
 225         ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 20);
 226         if (ret)
 227                 return ret;
 228
 229         v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
 230                           V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY,
 231                           0, 0, 1, 0);
 232
 233         v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
 234                           V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE,
 235                           0, 1, 1, 0);
 236
 237         ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
 238                                  V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 32, 1, 2);
 239         if (ctrl)
 240                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 241
 242         ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler, &vdec_ctrl_ops,
 243                                  V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 1, 32, 1, 2);
 244         if (ctrl)
 245                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 246
 247         if (inst->ctrl_handler.error) {
 248                 ret = inst->ctrl_handler.error;
 249                 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 250                 return ret;
 251         }
 252
 253         ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
 254         if (ret) {
 255                 dev_err(inst->dev, "[%d] setup ctrls fail, ret = %d\n", inst->id, ret);
 256                 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 257                 return ret;
 258         }
 259
 260         return 0;
 261 }
 262
 263 static void vdec_handle_resolution_change(struct vpu_inst *inst)
 264 {
 265         struct vdec_t *vdec = inst->priv;
 266         struct vb2_queue *q;
 267
 268         if (!inst->fh.m2m_ctx)
 269                 return;
 270
 271         if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
 272                 return;
 273         if (!vdec->source_change)
 274                 return;
 275
 276         q = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
 277         if (!list_empty(&q->done_list))
 278                 return;
 279
 280         vdec->source_change--;
 281         vpu_notify_source_change(inst);
 282         vpu_set_last_buffer_dequeued(inst, false);
 283 }
 284
 285 static int vdec_update_state(struct vpu_inst *inst, enum vpu_codec_state state, u32 force)
 286 {
 287         struct vdec_t *vdec = inst->priv;
 288         enum vpu_codec_state pre_state = inst->state;
 289
 290         if (state == VPU_CODEC_STATE_SEEK) {
 291                 if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
 292                         vdec->state = inst->state;
 293                 else
 294                         vdec->state = VPU_CODEC_STATE_ACTIVE;
 295         }
 296         if (inst->state != VPU_CODEC_STATE_SEEK || force)
 297                 inst->state = state;
 298         else if (state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
 299                 vdec->state = VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE;
 300
 301         if (inst->state != pre_state)
 302                 vpu_trace(inst->dev, "[%d] %s -> %s\n", inst->id,
 303                           vpu_codec_state_name(pre_state), vpu_codec_state_name(inst->state));
 304
 305         if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
 306                 vdec_handle_resolution_change(inst);
 307
 308         return 0;
 309 }
 310
 311 static void vdec_set_last_buffer_dequeued(struct vpu_inst *inst)
 312 {
 313         struct vdec_t *vdec = inst->priv;
 314
 315         if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
 316                 return;
 317
 318         if (vdec->eos_received) {
 319                 if (!vpu_set_last_buffer_dequeued(inst, true)) {
 320                         vdec->eos_received--;
 321                         vdec_update_state(inst, VPU_CODEC_STATE_DRAIN, 0);
 322                 }
 323         }
 324 }
 325
 326 static int vdec_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
 327 {
 328         strscpy(cap->driver, "amphion-vpu", sizeof(cap->driver));
 329         strscpy(cap->card, "amphion vpu decoder", sizeof(cap->card));
 330         strscpy(cap->bus_info, "platform: amphion-vpu", sizeof(cap->bus_info));
 331
 332         return 0;
 333 }
 334
 335 static int vdec_enum_fmt(struct file *file, void *fh, struct v4l2_fmtdesc *f)
 336 {
 337         struct vpu_inst *inst = to_inst(file);
 338         struct vdec_t *vdec = inst->priv;
 339         const struct vpu_format *fmt;
 340         int ret = -EINVAL;
 341
 342         vpu_inst_lock(inst);
 343         if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
 344                 fmt = vpu_get_format(inst, f->type);
 345                 if (f->index == 1)
 346                         fmt = vpu_helper_find_sibling(inst, f->type, fmt->pixfmt);
 347                 if (f->index > 1)
 348                         fmt = NULL;
 349         } else {
 350                 fmt = vpu_helper_enum_format(inst, f->type, f->index);
 351         }
 352         if (!fmt)
 353                 goto exit;
 354
 355         memset(f->reserved, 0, sizeof(f->reserved));
 356         f->pixelformat = fmt->pixfmt;
 357         f->flags = fmt->flags;
 358         ret = 0;
 359 exit:
 360         vpu_inst_unlock(inst);
 361         return ret;
 362 }
 363
 364 static int vdec_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
 365 {
 366         struct vpu_inst *inst = to_inst(file);
 367         struct vdec_t *vdec = inst->priv;
 368         struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
 369         struct vpu_format *cur_fmt;
 370         int i;
 371
 372         vpu_inst_lock(inst);
 373         cur_fmt = vpu_get_format(inst, f->type);
 374
 375         pixmp->pixelformat = cur_fmt->pixfmt;
 376         pixmp->num_planes = cur_fmt->mem_planes;
 377         pixmp->width = cur_fmt->width;
 378         pixmp->height = cur_fmt->height;
 379         pixmp->field = cur_fmt->field;
 380         pixmp->flags = cur_fmt->flags;
 381         for (i = 0; i < pixmp->num_planes; i++) {
 382                 pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
 383                 pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
 384         }
 385
 386         f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
 387         f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
 388         f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
 389         f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
 390         vpu_inst_unlock(inst);
 391
 392         return 0;
 393 }
 394
 395 static int vdec_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
 396 {
 397         struct vpu_inst *inst = to_inst(file);
 398         struct vdec_t *vdec = inst->priv;
 399         struct vpu_format fmt;
 400
 401         vpu_inst_lock(inst);
 402         if (V4L2_TYPE_IS_CAPTURE(f->type) && vdec->fixed_fmt) {
 403                 struct vpu_format *cap_fmt = vpu_get_format(inst, f->type);
 404
 405                 if (!vpu_helper_match_format(inst, cap_fmt->type, cap_fmt->pixfmt,
 406                                              f->fmt.pix_mp.pixelformat))
 407                         f->fmt.pix_mp.pixelformat = cap_fmt->pixfmt;
 408         }
 409
 410         vpu_try_fmt_common(inst, f, &fmt);
 411
 412         if (vdec->fixed_fmt) {
 413                 f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
 414                 f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
 415                 f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
 416                 f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
 417         } else {
 418                 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT;
 419                 f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;
 420                 f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 421                 f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;
 422         }
 423         vpu_inst_unlock(inst);
 424
 425         return 0;
 426 }
 427
 428 static int vdec_s_fmt_common(struct vpu_inst *inst, struct v4l2_format *f)
 429 {
 430         struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
 431         struct vpu_format fmt;
 432         struct vpu_format *cur_fmt;
 433         struct vb2_queue *q;
 434         struct vdec_t *vdec = inst->priv;
 435         int i;
 436
 437         if (!inst->fh.m2m_ctx)
 438                 return -EINVAL;
 439
 440         q = v4l2_m2m_get_vq(inst->fh.m2m_ctx, f->type);
 441         if (!q)
 442                 return -EINVAL;
 443         if (vb2_is_busy(q))
 444                 return -EBUSY;
 445
 446         if (vpu_try_fmt_common(inst, f, &fmt))
 447                 return -EINVAL;
 448
 449         cur_fmt = vpu_get_format(inst, f->type);
 450         if (V4L2_TYPE_IS_OUTPUT(f->type) && inst->state != VPU_CODEC_STATE_DEINIT) {
 451                 if (cur_fmt->pixfmt != fmt.pixfmt) {
 452                         vdec->reset_codec = true;
 453                         vdec->fixed_fmt = false;
 454                 }
 455         }
 456         if (V4L2_TYPE_IS_OUTPUT(f->type) || !vdec->fixed_fmt) {
 457                 memcpy(cur_fmt, &fmt, sizeof(*cur_fmt));
 458         } else {
 459                 if (vpu_helper_match_format(inst, f->type, cur_fmt->pixfmt, pixmp->pixelformat)) {
 460                         cur_fmt->pixfmt = fmt.pixfmt;
 461                         cur_fmt->mem_planes = fmt.mem_planes;
 462                 }
 463                 pixmp->pixelformat = cur_fmt->pixfmt;
 464                 pixmp->num_planes = cur_fmt->mem_planes;
 465                 pixmp->width = cur_fmt->width;
 466                 pixmp->height = cur_fmt->height;
 467                 for (i = 0; i < pixmp->num_planes; i++) {
 468                         pixmp->plane_fmt[i].bytesperline = cur_fmt->bytesperline[i];
 469                         pixmp->plane_fmt[i].sizeimage = vpu_get_fmt_plane_size(cur_fmt, i);
 470                 }
 471                 pixmp->field = cur_fmt->field;
 472         }
 473
 474         if (!vdec->fixed_fmt) {
 475                 if (V4L2_TYPE_IS_OUTPUT(f->type)) {
 476                         vdec->params.codec_format = cur_fmt->pixfmt;
 477                         vdec->codec_info.color_primaries = f->fmt.pix_mp.colorspace;
 478                         vdec->codec_info.transfer_chars = f->fmt.pix_mp.xfer_func;
 479                         vdec->codec_info.matrix_coeffs = f->fmt.pix_mp.ycbcr_enc;
 480                         vdec->codec_info.full_range = f->fmt.pix_mp.quantization;
 481                 } else {
 482                         vdec->params.output_format = cur_fmt->pixfmt;
 483                         inst->crop.left = 0;
 484                         inst->crop.top = 0;
 485                         inst->crop.width = cur_fmt->width;
 486                         inst->crop.height = cur_fmt->height;
 487                 }
 488         }
 489
 490         vpu_trace(inst->dev, "[%d] %c%c%c%c %dx%d\n", inst->id,
 491                   f->fmt.pix_mp.pixelformat,
 492                   f->fmt.pix_mp.pixelformat >> 8,
 493                   f->fmt.pix_mp.pixelformat >> 16,
 494                   f->fmt.pix_mp.pixelformat >> 24,
 495                   f->fmt.pix_mp.width,
 496                   f->fmt.pix_mp.height);
 497
 498         return 0;
 499 }
 500
 501 static int vdec_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
 502 {
 503         struct vpu_inst *inst = to_inst(file);
 504         struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp;
 505         struct vdec_t *vdec = inst->priv;
 506         int ret = 0;
 507
 508         vpu_inst_lock(inst);
 509         ret = vdec_s_fmt_common(inst, f);
 510         if (ret)
 511                 goto exit;
 512
 513         if (V4L2_TYPE_IS_OUTPUT(f->type) && !vdec->fixed_fmt) {
 514                 struct v4l2_format fc;
 515
 516                 memset(&fc, 0, sizeof(fc));
 517                 fc.type = inst->cap_format.type;
 518                 fc.fmt.pix_mp.pixelformat = inst->cap_format.pixfmt;
 519                 fc.fmt.pix_mp.width = pixmp->width;
 520                 fc.fmt.pix_mp.height = pixmp->height;
 521                 vdec_s_fmt_common(inst, &fc);
 522         }
 523
 524         f->fmt.pix_mp.colorspace = vdec->codec_info.color_primaries;
 525         f->fmt.pix_mp.xfer_func = vdec->codec_info.transfer_chars;
 526         f->fmt.pix_mp.ycbcr_enc = vdec->codec_info.matrix_coeffs;
 527         f->fmt.pix_mp.quantization = vdec->codec_info.full_range;
 528
 529 exit:
 530         vpu_inst_unlock(inst);
 531         return ret;
 532 }
 533
 534 static int vdec_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
 535 {
 536         struct vpu_inst *inst = to_inst(file);
 537
 538         if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 539                 return -EINVAL;
 540
 541         switch (s->target) {
 542         case V4L2_SEL_TGT_COMPOSE:
 543         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 544         case V4L2_SEL_TGT_COMPOSE_PADDED:
 545                 s->r = inst->crop;
 546                 break;
 547         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 548                 s->r.left = 0;
 549                 s->r.top = 0;
 550                 s->r.width = inst->cap_format.width;
 551                 s->r.height = inst->cap_format.height;
 552                 break;
 553         default:
 554                 return -EINVAL;
 555         }
 556
 557         return 0;
 558 }
 559
 560 static int vdec_drain(struct vpu_inst *inst)
 561 {
 562         struct vdec_t *vdec = inst->priv;
 563
 564         if (!inst->fh.m2m_ctx)
 565                 return 0;
 566
 567         if (!vdec->drain)
 568                 return 0;
 569
 570         if (!vpu_is_source_empty(inst))
 571                 return 0;
 572
 573         if (!vdec->params.frame_count) {
 574                 vpu_set_last_buffer_dequeued(inst, true);
 575                 return 0;
 576         }
 577
 578         vpu_iface_add_scode(inst, SCODE_PADDING_EOS);
 579         vdec->params.end_flag = 1;
 580         vpu_iface_set_decode_params(inst, &vdec->params, 1);
 581         vdec->drain = 0;
 582         vpu_trace(inst->dev, "[%d] frame_count = %d\n", inst->id, vdec->params.frame_count);
 583
 584         return 0;
 585 }
 586
 587 static int vdec_cmd_start(struct vpu_inst *inst)
 588 {
 589         struct vdec_t *vdec = inst->priv;
 590
 591         switch (inst->state) {
 592         case VPU_CODEC_STATE_STARTED:
 593         case VPU_CODEC_STATE_DRAIN:
 594         case VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE:
 595                 vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
 596                 break;
 597         default:
 598                 break;
 599         }
 600         vpu_process_capture_buffer(inst);
 601         if (vdec->eos_received)
 602                 vdec_set_last_buffer_dequeued(inst);
 603         return 0;
 604 }
 605
 606 static int vdec_cmd_stop(struct vpu_inst *inst)
 607 {
 608         struct vdec_t *vdec = inst->priv;
 609
 610         vpu_trace(inst->dev, "[%d]\n", inst->id);
 611
 612         if (inst->state == VPU_CODEC_STATE_DEINIT) {
 613                 vpu_set_last_buffer_dequeued(inst, true);
 614         } else {
 615                 vdec->drain = 1;
 616                 vdec_drain(inst);
 617         }
 618
 619         return 0;
 620 }
 621
 622 static int vdec_decoder_cmd(struct file *file, void *fh, struct v4l2_decoder_cmd *cmd)
 623 {
 624         struct vpu_inst *inst = to_inst(file);
 625         int ret;
 626
 627         ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd);
 628         if (ret)
 629                 return ret;
 630
 631         vpu_inst_lock(inst);
 632         switch (cmd->cmd) {
 633         case V4L2_DEC_CMD_START:
 634                 vdec_cmd_start(inst);
 635                 break;
 636         case V4L2_DEC_CMD_STOP:
 637                 vdec_cmd_stop(inst);
 638                 break;
 639         default:
 640                 break;
 641         }
 642         vpu_inst_unlock(inst);
 643
 644         return 0;
 645 }
 646
 647 static int vdec_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub)
 648 {
 649         switch (sub->type) {
 650         case V4L2_EVENT_EOS:
 651                 return v4l2_event_subscribe(fh, sub, 0, NULL);
 652         case V4L2_EVENT_SOURCE_CHANGE:
 653                 return v4l2_src_change_event_subscribe(fh, sub);
 654         case V4L2_EVENT_CTRL:
 655                 return v4l2_ctrl_subscribe_event(fh, sub);
 656         default:
 657                 return -EINVAL;
 658         }
 659
 660         return 0;
 661 }
 662
 663 static const struct v4l2_ioctl_ops vdec_ioctl_ops = {
 664         .vidioc_querycap               = vdec_querycap,
 665         .vidioc_enum_fmt_vid_cap       = vdec_enum_fmt,
 666         .vidioc_enum_fmt_vid_out       = vdec_enum_fmt,
 667         .vidioc_g_fmt_vid_cap_mplane   = vdec_g_fmt,
 668         .vidioc_g_fmt_vid_out_mplane   = vdec_g_fmt,
 669         .vidioc_try_fmt_vid_cap_mplane = vdec_try_fmt,
 670         .vidioc_try_fmt_vid_out_mplane = vdec_try_fmt,
 671         .vidioc_s_fmt_vid_cap_mplane   = vdec_s_fmt,
 672         .vidioc_s_fmt_vid_out_mplane   = vdec_s_fmt,
 673         .vidioc_g_selection            = vdec_g_selection,
 674         .vidioc_try_decoder_cmd        = v4l2_m2m_ioctl_try_decoder_cmd,
 675         .vidioc_decoder_cmd            = vdec_decoder_cmd,
 676         .vidioc_subscribe_event        = vdec_subscribe_event,
 677         .vidioc_unsubscribe_event      = v4l2_event_unsubscribe,
 678         .vidioc_reqbufs                = v4l2_m2m_ioctl_reqbufs,
 679         .vidioc_create_bufs            = v4l2_m2m_ioctl_create_bufs,
 680         .vidioc_prepare_buf            = v4l2_m2m_ioctl_prepare_buf,
 681         .vidioc_querybuf               = v4l2_m2m_ioctl_querybuf,
 682         .vidioc_qbuf                   = v4l2_m2m_ioctl_qbuf,
 683         .vidioc_expbuf                 = v4l2_m2m_ioctl_expbuf,
 684         .vidioc_dqbuf                  = v4l2_m2m_ioctl_dqbuf,
 685         .vidioc_streamon               = v4l2_m2m_ioctl_streamon,
 686         .vidioc_streamoff              = v4l2_m2m_ioctl_streamoff,
 687 };
 688
 689 static bool vdec_check_ready(struct vpu_inst *inst, unsigned int type)
 690 {
 691         struct vdec_t *vdec = inst->priv;
 692
 693         if (V4L2_TYPE_IS_OUTPUT(type))
 694                 return true;
 695
 696         if (vdec->req_frame_count)
 697                 return true;
 698
 699         return false;
 700 }
 701
 702 static struct vb2_v4l2_buffer *vdec_get_src_buffer(struct vpu_inst *inst, u32 count)
 703 {
 704         if (count > 1)
 705                 vpu_skip_frame(inst, count - 1);
 706
 707         return vpu_next_src_buf(inst);
 708 }
 709
 710 static int vdec_frame_decoded(struct vpu_inst *inst, void *arg)
 711 {
 712         struct vdec_t *vdec = inst->priv;
 713         struct vpu_dec_pic_info *info = arg;
 714         struct vpu_vb2_buffer *vpu_buf;
 715         struct vb2_v4l2_buffer *vbuf;
 716         struct vb2_v4l2_buffer *src_buf;
 717         int ret = 0;
 718
 719         if (!info || info->id >= ARRAY_SIZE(vdec->slots))
 720                 return -EINVAL;
 721
 722         vpu_inst_lock(inst);
 723         vpu_buf = vdec->slots[info->id];
 724         if (!vpu_buf) {
 725                 dev_err(inst->dev, "[%d] decoded invalid frame[%d]\n", inst->id, info->id);
 726                 ret = -EINVAL;
 727                 goto exit;
 728         }
 729         vbuf = &vpu_buf->m2m_buf.vb;
 730         src_buf = vdec_get_src_buffer(inst, info->consumed_count);
 731         if (src_buf) {
 732                 v4l2_m2m_buf_copy_metadata(src_buf, vbuf, true);
 733                 if (info->consumed_count) {
 734                         v4l2_m2m_src_buf_remove(inst->fh.m2m_ctx);
 735                         vpu_set_buffer_state(src_buf, VPU_BUF_STATE_IDLE);
 736                         v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
 737                 } else {
 738                         vpu_set_buffer_state(src_buf, VPU_BUF_STATE_DECODED);
 739                 }
 740         }
 741         if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED)
 742                 dev_info(inst->dev, "[%d] buf[%d] has been decoded\n", inst->id, info->id);
 743         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_DECODED);
 744         vdec->decoded_frame_count++;
 745         if (vdec->params.display_delay_enable) {
 746                 struct vpu_format *cur_fmt;
 747
 748                 cur_fmt = vpu_get_format(inst, inst->cap_format.type);
 749                 vpu_set_buffer_state(vbuf, VPU_BUF_STATE_READY);
 750                 for (int i = 0; i < vbuf->vb2_buf.num_planes; i++)
 751                         vb2_set_plane_payload(&vbuf->vb2_buf,
 752                                               i, vpu_get_fmt_plane_size(cur_fmt, i));
 753                 vbuf->field = cur_fmt->field;
 754                 vbuf->sequence = vdec->sequence++;
 755                 dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
 756
 757                 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
 758                 vdec->display_frame_count++;
 759         }
 760 exit:
 761         vpu_inst_unlock(inst);
 762
 763         return ret;
 764 }
 765
 766 static struct vpu_vb2_buffer *vdec_find_buffer(struct vpu_inst *inst, u32 luma)
 767 {
 768         struct vdec_t *vdec = inst->priv;
 769         int i;
 770
 771         for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
 772                 if (!vdec->slots[i])
 773                         continue;
 774                 if (luma == vdec->slots[i]->luma)
 775                         return vdec->slots[i];
 776         }
 777
 778         return NULL;
 779 }
 780
 781 static void vdec_buf_done(struct vpu_inst *inst, struct vpu_frame_info *frame)
 782 {
 783         struct vdec_t *vdec = inst->priv;
 784         struct vpu_format *cur_fmt;
 785         struct vpu_vb2_buffer *vpu_buf;
 786         struct vb2_v4l2_buffer *vbuf;
 787         int i;
 788
 789         if (!frame)
 790                 return;
 791
 792         vpu_inst_lock(inst);
 793         if (!vdec->params.display_delay_enable)
 794                 vdec->sequence++;
 795         vpu_buf = vdec_find_buffer(inst, frame->luma);
 796         vpu_inst_unlock(inst);
 797         if (!vpu_buf) {
 798                 dev_err(inst->dev, "[%d] can't find buffer, id = %d, addr = 0x%x\n",
 799                         inst->id, frame->id, frame->luma);
 800                 return;
 801         }
 802         if (frame->skipped) {
 803                 dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
 804                 return;
 805         }
 806
 807         cur_fmt = vpu_get_format(inst, inst->cap_format.type);
 808         vbuf = &vpu_buf->m2m_buf.vb;
 809         if (vbuf->vb2_buf.index != frame->id)
 810                 dev_err(inst->dev, "[%d] buffer id(%d, %d) dismatch\n",
 811                         inst->id, vbuf->vb2_buf.index, frame->id);
 812
 813         if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_READY && vdec->params.display_delay_enable)
 814                 return;
 815
 816         if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_DECODED)
 817                 dev_err(inst->dev, "[%d] buffer(%d) ready without decoded\n", inst->id, frame->id);
 818
 819         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_READY);
 820         for (i = 0; i < vbuf->vb2_buf.num_planes; i++)
 821                 vb2_set_plane_payload(&vbuf->vb2_buf, i, vpu_get_fmt_plane_size(cur_fmt, i));
 822         vbuf->field = cur_fmt->field;
 823         vbuf->sequence = vdec->sequence;
 824         dev_dbg(inst->dev, "[%d][OUTPUT TS]%32lld\n", inst->id, vbuf->vb2_buf.timestamp);
 825
 826         v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);
 827         vpu_inst_lock(inst);
 828         vdec->display_frame_count++;
 829         vpu_inst_unlock(inst);
 830         dev_dbg(inst->dev, "[%d] decoded : %d, display : %d, sequence : %d\n",
 831                 inst->id, vdec->decoded_frame_count, vdec->display_frame_count, vdec->sequence);
 832 }
 833
 834 static void vdec_stop_done(struct vpu_inst *inst)
 835 {
 836         struct vdec_t *vdec = inst->priv;
 837
 838         vpu_inst_lock(inst);
 839         vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 0);
 840         vdec->seq_hdr_found = 0;
 841         vdec->req_frame_count = 0;
 842         vdec->reset_codec = false;
 843         vdec->fixed_fmt = false;
 844         vdec->params.end_flag = 0;
 845         vdec->drain = 0;
 846         vdec->params.frame_count = 0;
 847         vdec->decoded_frame_count = 0;
 848         vdec->display_frame_count = 0;
 849         vdec->sequence = 0;
 850         vdec->eos_received = 0;
 851         vdec->is_source_changed = false;
 852         vdec->source_change = 0;
 853         inst->total_input_count = 0;
 854         vpu_inst_unlock(inst);
 855 }
 856
 857 static bool vdec_check_source_change(struct vpu_inst *inst)
 858 {
 859         struct vdec_t *vdec = inst->priv;
 860         const struct vpu_format *sibling;
 861
 862         if (!inst->fh.m2m_ctx)
 863                 return false;
 864
 865         if (vdec->reset_codec)
 866                 return false;
 867
 868         sibling = vpu_helper_find_sibling(inst, inst->cap_format.type, inst->cap_format.pixfmt);
 869         if (sibling && vdec->codec_info.pixfmt == sibling->pixfmt)
 870                 vdec->codec_info.pixfmt = inst->cap_format.pixfmt;
 871
 872         if (!vb2_is_streaming(v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx)))
 873                 return true;
 874         if (inst->cap_format.pixfmt != vdec->codec_info.pixfmt)
 875                 return true;
 876         if (inst->cap_format.width != vdec->codec_info.decoded_width)
 877                 return true;
 878         if (inst->cap_format.height != vdec->codec_info.decoded_height)
 879                 return true;
 880         if (vpu_get_num_buffers(inst, inst->cap_format.type) < inst->min_buffer_cap)
 881                 return true;
 882         if (inst->crop.left != vdec->codec_info.offset_x)
 883                 return true;
 884         if (inst->crop.top != vdec->codec_info.offset_y)
 885                 return true;
 886         if (inst->crop.width != vdec->codec_info.width)
 887                 return true;
 888         if (inst->crop.height != vdec->codec_info.height)
 889                 return true;
 890
 891         return false;
 892 }
 893
 894 static void vdec_init_fmt(struct vpu_inst *inst)
 895 {
 896         struct vdec_t *vdec = inst->priv;
 897         struct v4l2_format f;
 898
 899         memset(&f, 0, sizeof(f));
 900         f.type = inst->cap_format.type;
 901         f.fmt.pix_mp.pixelformat = vdec->codec_info.pixfmt;
 902         f.fmt.pix_mp.width = vdec->codec_info.decoded_width;
 903         f.fmt.pix_mp.height = vdec->codec_info.decoded_height;
 904         if (vdec->codec_info.progressive)
 905                 f.fmt.pix_mp.field = V4L2_FIELD_NONE;
 906         else
 907                 f.fmt.pix_mp.field = V4L2_FIELD_SEQ_TB;
 908         vpu_try_fmt_common(inst, &f, &inst->cap_format);
 909
 910         inst->out_format.width = vdec->codec_info.width;
 911         inst->out_format.height = vdec->codec_info.height;
 912 }
 913
 914 static void vdec_init_crop(struct vpu_inst *inst)
 915 {
 916         struct vdec_t *vdec = inst->priv;
 917
 918         inst->crop.left = vdec->codec_info.offset_x;
 919         inst->crop.top = vdec->codec_info.offset_y;
 920         inst->crop.width = vdec->codec_info.width;
 921         inst->crop.height = vdec->codec_info.height;
 922 }
 923
 924 static void vdec_init_mbi(struct vpu_inst *inst)
 925 {
 926         struct vdec_t *vdec = inst->priv;
 927
 928         vdec->mbi.size = vdec->codec_info.mbi_size;
 929         vdec->mbi.max_count = ARRAY_SIZE(vdec->mbi.buffer);
 930         scnprintf(vdec->mbi.name, sizeof(vdec->mbi.name), "mbi");
 931         vdec->mbi.type = MEM_RES_MBI;
 932         vdec->mbi.tag = vdec->seq_tag;
 933 }
 934
 935 static void vdec_init_dcp(struct vpu_inst *inst)
 936 {
 937         struct vdec_t *vdec = inst->priv;
 938
 939         vdec->dcp.size = vdec->codec_info.dcp_size;
 940         vdec->dcp.max_count = ARRAY_SIZE(vdec->dcp.buffer);
 941         scnprintf(vdec->dcp.name, sizeof(vdec->dcp.name), "dcp");
 942         vdec->dcp.type = MEM_RES_DCP;
 943         vdec->dcp.tag = vdec->seq_tag;
 944 }
 945
 946 static void vdec_request_one_fs(struct vdec_fs_info *fs)
 947 {
 948         fs->req_count++;
 949         if (fs->req_count > fs->max_count)
 950                 fs->req_count = fs->max_count;
 951 }
 952
 953 static int vdec_alloc_fs_buffer(struct vpu_inst *inst, struct vdec_fs_info *fs)
 954 {
 955         struct vpu_buffer *buffer;
 956
 957         if (!fs->size)
 958                 return -EINVAL;
 959
 960         if (fs->count >= fs->req_count)
 961                 return -EINVAL;
 962
 963         buffer = &fs->buffer[fs->count];
 964         if (buffer->virt && buffer->length >= fs->size)
 965                 return 0;
 966
 967         vpu_free_dma(buffer);
 968         buffer->length = fs->size;
 969         return vpu_alloc_dma(inst->core, buffer);
 970 }
 971
 972 static void vdec_alloc_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
 973 {
 974         int ret;
 975
 976         while (fs->count < fs->req_count) {
 977                 ret = vdec_alloc_fs_buffer(inst, fs);
 978                 if (ret)
 979                         break;
 980                 fs->count++;
 981         }
 982 }
 983
 984 static void vdec_clear_fs(struct vdec_fs_info *fs)
 985 {
 986         u32 i;
 987
 988         if (!fs)
 989                 return;
 990
 991         for (i = 0; i < ARRAY_SIZE(fs->buffer); i++)
 992                 vpu_free_dma(&fs->buffer[i]);
 993         memset(fs, 0, sizeof(*fs));
 994 }
 995
 996 static int vdec_response_fs(struct vpu_inst *inst, struct vdec_fs_info *fs)
 997 {
 998         struct vpu_fs_info info;
 999         int ret;
1000
1001         if (fs->index >= fs->count)
1002                 return 0;
1003
1004         memset(&info, 0, sizeof(info));
1005         info.id = fs->index;
1006         info.type = fs->type;
1007         info.tag = fs->tag;
1008         info.luma_addr = fs->buffer[fs->index].phys;
1009         info.luma_size = fs->buffer[fs->index].length;
1010         ret = vpu_session_alloc_fs(inst, &info);
1011         if (ret)
1012                 return ret;
1013
1014         fs->index++;
1015         return 0;
1016 }
1017
1018 static int vdec_response_frame_abnormal(struct vpu_inst *inst)
1019 {
1020         struct vdec_t *vdec = inst->priv;
1021         struct vpu_fs_info info;
1022         int ret;
1023
1024         if (!vdec->req_frame_count)
1025                 return 0;
1026
1027         memset(&info, 0, sizeof(info));
1028         info.type = MEM_RES_FRAME;
1029         info.tag = vdec->seq_tag + 0xf0;
1030         ret = vpu_session_alloc_fs(inst, &info);
1031         if (ret)
1032                 return ret;
1033         vdec->req_frame_count--;
1034
1035         return 0;
1036 }
1037
1038 static int vdec_response_frame(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1039 {
1040         struct vdec_t *vdec = inst->priv;
1041         struct vpu_vb2_buffer *vpu_buf;
1042         struct vpu_fs_info info;
1043         int ret;
1044
1045         if (inst->state != VPU_CODEC_STATE_ACTIVE)
1046                 return -EINVAL;
1047
1048         if (vdec->aborting)
1049                 return -EINVAL;
1050
1051         if (!vdec->req_frame_count)
1052                 return -EINVAL;
1053
1054         if (!vbuf)
1055                 return -EINVAL;
1056
1057         if (vdec->slots[vbuf->vb2_buf.index]) {
1058                 dev_err(inst->dev, "[%d] repeat alloc fs %d\n",
1059                         inst->id, vbuf->vb2_buf.index);
1060                 return -EINVAL;
1061         }
1062
1063         dev_dbg(inst->dev, "[%d] state = %s, alloc fs %d, tag = 0x%x\n",
1064                 inst->id, vpu_codec_state_name(inst->state), vbuf->vb2_buf.index, vdec->seq_tag);
1065         vpu_buf = to_vpu_vb2_buffer(vbuf);
1066
1067         memset(&info, 0, sizeof(info));
1068         info.id = vbuf->vb2_buf.index;
1069         info.type = MEM_RES_FRAME;
1070         info.tag = vdec->seq_tag;
1071         info.luma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 0);
1072         info.luma_size = inst->cap_format.sizeimage[0];
1073         if (vbuf->vb2_buf.num_planes > 1)
1074                 info.chroma_addr = vpu_get_vb_phy_addr(&vbuf->vb2_buf, 1);
1075         else
1076                 info.chroma_addr = info.luma_addr + info.luma_size;
1077         info.chromau_size = inst->cap_format.sizeimage[1];
1078         info.bytesperline = inst->cap_format.bytesperline[0];
1079         ret = vpu_session_alloc_fs(inst, &info);
1080         if (ret)
1081                 return ret;
1082
1083         vpu_buf->tag = info.tag;
1084         vpu_buf->luma = info.luma_addr;
1085         vpu_buf->chroma_u = info.chroma_addr;
1086         vpu_buf->chroma_v = 0;
1087         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1088         vdec->slots[info.id] = vpu_buf;
1089         vdec->req_frame_count--;
1090
1091         return 0;
1092 }
1093
1094 static void vdec_response_fs_request(struct vpu_inst *inst, bool force)
1095 {
1096         struct vdec_t *vdec = inst->priv;
1097         int i;
1098         int ret;
1099
1100         if (force) {
1101                 for (i = vdec->req_frame_count; i > 0; i--)
1102                         vdec_response_frame_abnormal(inst);
1103                 return;
1104         }
1105
1106         for (i = vdec->req_frame_count; i > 0; i--) {
1107                 ret = vpu_process_capture_buffer(inst);
1108                 if (ret)
1109                         break;
1110                 if (vdec->eos_received)
1111                         break;
1112         }
1113
1114         for (i = vdec->mbi.index; i < vdec->mbi.count; i++) {
1115                 if (vdec_response_fs(inst, &vdec->mbi))
1116                         break;
1117                 if (vdec->eos_received)
1118                         break;
1119         }
1120         for (i = vdec->dcp.index; i < vdec->dcp.count; i++) {
1121                 if (vdec_response_fs(inst, &vdec->dcp))
1122                         break;
1123                 if (vdec->eos_received)
1124                         break;
1125         }
1126 }
1127
1128 static void vdec_response_fs_release(struct vpu_inst *inst, u32 id, u32 tag)
1129 {
1130         struct vpu_fs_info info;
1131
1132         memset(&info, 0, sizeof(info));
1133         info.id = id;
1134         info.tag = tag;
1135         vpu_session_release_fs(inst, &info);
1136 }
1137
1138 static void vdec_recycle_buffer(struct vpu_inst *inst, struct vb2_v4l2_buffer *vbuf)
1139 {
1140         if (!inst->fh.m2m_ctx)
1141                 return;
1142         if (vbuf->vb2_buf.state != VB2_BUF_STATE_ACTIVE)
1143                 return;
1144         if (vpu_find_buf_by_idx(inst, vbuf->vb2_buf.type, vbuf->vb2_buf.index))
1145                 return;
1146         v4l2_m2m_buf_queue(inst->fh.m2m_ctx, vbuf);
1147 }
1148
1149 static void vdec_clear_slots(struct vpu_inst *inst)
1150 {
1151         struct vdec_t *vdec = inst->priv;
1152         struct vpu_vb2_buffer *vpu_buf;
1153         struct vb2_v4l2_buffer *vbuf;
1154         int i;
1155
1156         for (i = 0; i < ARRAY_SIZE(vdec->slots); i++) {
1157                 if (!vdec->slots[i])
1158                         continue;
1159
1160                 vpu_buf = vdec->slots[i];
1161                 vbuf = &vpu_buf->m2m_buf.vb;
1162
1163                 vpu_trace(inst->dev, "clear slot %d\n", i);
1164                 vdec_response_fs_release(inst, i, vpu_buf->tag);
1165                 vdec_recycle_buffer(inst, vbuf);
1166                 vdec->slots[i]->state = VPU_BUF_STATE_IDLE;
1167                 vdec->slots[i] = NULL;
1168         }
1169 }
1170
1171 static void vdec_event_seq_hdr(struct vpu_inst *inst, struct vpu_dec_codec_info *hdr)
1172 {
1173         struct vdec_t *vdec = inst->priv;
1174
1175         vpu_inst_lock(inst);
1176         memcpy(&vdec->codec_info, hdr, sizeof(vdec->codec_info));
1177
1178         vpu_trace(inst->dev, "[%d] %d x %d, crop : (%d, %d) %d x %d, %d, %d\n",
1179                   inst->id,
1180                   vdec->codec_info.decoded_width,
1181                   vdec->codec_info.decoded_height,
1182                   vdec->codec_info.offset_x,
1183                   vdec->codec_info.offset_y,
1184                   vdec->codec_info.width,
1185                   vdec->codec_info.height,
1186                   hdr->num_ref_frms,
1187                   hdr->num_dpb_frms);
1188         inst->min_buffer_cap = hdr->num_ref_frms + hdr->num_dpb_frms;
1189         vdec->is_source_changed = vdec_check_source_change(inst);
1190         vdec_init_fmt(inst);
1191         vdec_init_crop(inst);
1192         vdec_init_mbi(inst);
1193         vdec_init_dcp(inst);
1194         if (!vdec->seq_hdr_found) {
1195                 vdec->seq_tag = vdec->codec_info.tag;
1196                 if (vdec->is_source_changed) {
1197                         vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1198                         vdec->source_change++;
1199                         vdec_handle_resolution_change(inst);
1200                         vdec->is_source_changed = false;
1201                 }
1202         }
1203         if (vdec->seq_tag != vdec->codec_info.tag) {
1204                 vdec_response_fs_request(inst, true);
1205                 vpu_trace(inst->dev, "[%d] seq tag change: %d -> %d\n",
1206                           inst->id, vdec->seq_tag, vdec->codec_info.tag);
1207         }
1208         vdec->seq_hdr_found++;
1209         vdec->fixed_fmt = true;
1210         vpu_inst_unlock(inst);
1211 }
1212
1213 static void vdec_event_resolution_change(struct vpu_inst *inst)
1214 {
1215         struct vdec_t *vdec = inst->priv;
1216
1217         vpu_trace(inst->dev, "[%d]\n", inst->id);
1218         vpu_inst_lock(inst);
1219         vdec->seq_tag = vdec->codec_info.tag;
1220         vdec_clear_fs(&vdec->mbi);
1221         vdec_clear_fs(&vdec->dcp);
1222         vdec_clear_slots(inst);
1223         vdec_init_mbi(inst);
1224         vdec_init_dcp(inst);
1225         if (vdec->is_source_changed) {
1226                 vdec_update_state(inst, VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE, 0);
1227                 vdec->source_change++;
1228                 vdec_handle_resolution_change(inst);
1229                 vdec->is_source_changed = false;
1230         }
1231         vpu_inst_unlock(inst);
1232 }
1233
1234 static void vdec_event_req_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1235 {
1236         struct vdec_t *vdec = inst->priv;
1237
1238         if (!fs)
1239                 return;
1240
1241         vpu_inst_lock(inst);
1242
1243         switch (fs->type) {
1244         case MEM_RES_FRAME:
1245                 vdec->req_frame_count++;
1246                 break;
1247         case MEM_RES_MBI:
1248                 vdec_request_one_fs(&vdec->mbi);
1249                 break;
1250         case MEM_RES_DCP:
1251                 vdec_request_one_fs(&vdec->dcp);
1252                 break;
1253         default:
1254                 break;
1255         }
1256
1257         vdec_alloc_fs(inst, &vdec->mbi);
1258         vdec_alloc_fs(inst, &vdec->dcp);
1259
1260         vdec_response_fs_request(inst, false);
1261
1262         vpu_inst_unlock(inst);
1263 }
1264
1265 static void vdec_evnet_rel_fs(struct vpu_inst *inst, struct vpu_fs_info *fs)
1266 {
1267         struct vdec_t *vdec = inst->priv;
1268         struct vpu_vb2_buffer *vpu_buf;
1269         struct vb2_v4l2_buffer *vbuf;
1270
1271         if (!fs || fs->id >= ARRAY_SIZE(vdec->slots))
1272                 return;
1273         if (fs->type != MEM_RES_FRAME)
1274                 return;
1275
1276         if (fs->id >= vpu_get_num_buffers(inst, inst->cap_format.type)) {
1277                 dev_err(inst->dev, "[%d] invalid fs(%d) to release\n", inst->id, fs->id);
1278                 return;
1279         }
1280
1281         vpu_inst_lock(inst);
1282         vpu_buf = vdec->slots[fs->id];
1283         vdec->slots[fs->id] = NULL;
1284
1285         if (!vpu_buf) {
1286                 dev_dbg(inst->dev, "[%d] fs[%d] has bee released\n", inst->id, fs->id);
1287                 goto exit;
1288         }
1289
1290         vbuf = &vpu_buf->m2m_buf.vb;
1291         if (vpu_get_buffer_state(vbuf) == VPU_BUF_STATE_DECODED) {
1292                 dev_dbg(inst->dev, "[%d] frame skip\n", inst->id);
1293                 vdec->sequence++;
1294         }
1295
1296         vdec_response_fs_release(inst, fs->id, vpu_buf->tag);
1297         if (vpu_get_buffer_state(vbuf) != VPU_BUF_STATE_READY)
1298                 vdec_recycle_buffer(inst, vbuf);
1299
1300         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_IDLE);
1301         vpu_process_capture_buffer(inst);
1302
1303 exit:
1304         vpu_inst_unlock(inst);
1305 }
1306
1307 static void vdec_event_eos(struct vpu_inst *inst)
1308 {
1309         struct vdec_t *vdec = inst->priv;
1310
1311         vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1312                   inst->id,
1313                   vdec->params.frame_count,
1314                   vdec->decoded_frame_count,
1315                   vdec->display_frame_count,
1316                   vdec->sequence);
1317         vpu_inst_lock(inst);
1318         vdec->eos_received++;
1319         vdec->fixed_fmt = false;
1320         inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1321         vdec_set_last_buffer_dequeued(inst);
1322         vpu_inst_unlock(inst);
1323 }
1324
1325 static void vdec_event_notify(struct vpu_inst *inst, u32 event, void *data)
1326 {
1327         switch (event) {
1328         case VPU_MSG_ID_SEQ_HDR_FOUND:
1329                 vdec_event_seq_hdr(inst, data);
1330                 break;
1331         case VPU_MSG_ID_RES_CHANGE:
1332                 vdec_event_resolution_change(inst);
1333                 break;
1334         case VPU_MSG_ID_FRAME_REQ:
1335                 vdec_event_req_fs(inst, data);
1336                 break;
1337         case VPU_MSG_ID_FRAME_RELEASE:
1338                 vdec_evnet_rel_fs(inst, data);
1339                 break;
1340         case VPU_MSG_ID_PIC_EOS:
1341                 vdec_event_eos(inst);
1342                 break;
1343         default:
1344                 break;
1345         }
1346 }
1347
1348 static int vdec_process_output(struct vpu_inst *inst, struct vb2_buffer *vb)
1349 {
1350         struct vdec_t *vdec = inst->priv;
1351         struct vb2_v4l2_buffer *vbuf;
1352         struct vpu_rpc_buffer_desc desc;
1353         u32 free_space;
1354         int ret;
1355
1356         vbuf = to_vb2_v4l2_buffer(vb);
1357         dev_dbg(inst->dev, "[%d] dec output [%d] %d : %ld\n",
1358                 inst->id, vbuf->sequence, vb->index, vb2_get_plane_payload(vb, 0));
1359
1360         if (inst->state == VPU_CODEC_STATE_DEINIT)
1361                 return -EINVAL;
1362         if (vdec->reset_codec)
1363                 return -EINVAL;
1364
1365         if (inst->state == VPU_CODEC_STATE_STARTED)
1366                 vdec_update_state(inst, VPU_CODEC_STATE_ACTIVE, 0);
1367
1368         ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1369         if (ret)
1370                 return ret;
1371
1372         free_space = vpu_helper_get_free_space(inst);
1373         if (free_space < vb2_get_plane_payload(vb, 0) + 0x40000)
1374                 return -ENOMEM;
1375
1376         vpu_set_buffer_state(vbuf, VPU_BUF_STATE_INUSE);
1377         ret = vpu_iface_input_frame(inst, vb);
1378         if (ret < 0)
1379                 return -ENOMEM;
1380
1381         dev_dbg(inst->dev, "[%d][INPUT  TS]%32lld\n", inst->id, vb->timestamp);
1382         vdec->params.frame_count++;
1383
1384         if (vdec->drain)
1385                 vdec_drain(inst);
1386
1387         return 0;
1388 }
1389
1390 static int vdec_process_capture(struct vpu_inst *inst, struct vb2_buffer *vb)
1391 {
1392         struct vdec_t *vdec = inst->priv;
1393         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1394         int ret;
1395
1396         if (inst->state == VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE)
1397                 return -EINVAL;
1398         if (vdec->reset_codec)
1399                 return -EINVAL;
1400
1401         ret = vdec_response_frame(inst, vbuf);
1402         if (ret)
1403                 return ret;
1404         v4l2_m2m_dst_buf_remove_by_buf(inst->fh.m2m_ctx, vbuf);
1405         return 0;
1406 }
1407
1408 static void vdec_on_queue_empty(struct vpu_inst *inst, u32 type)
1409 {
1410         struct vdec_t *vdec = inst->priv;
1411
1412         if (V4L2_TYPE_IS_OUTPUT(type))
1413                 return;
1414
1415         vdec_handle_resolution_change(inst);
1416         if (vdec->eos_received)
1417                 vdec_set_last_buffer_dequeued(inst);
1418 }
1419
1420 static void vdec_abort(struct vpu_inst *inst)
1421 {
1422         struct vdec_t *vdec = inst->priv;
1423         struct vpu_rpc_buffer_desc desc;
1424         int ret;
1425
1426         vpu_trace(inst->dev, "[%d] state = %s\n", inst->id, vpu_codec_state_name(inst->state));
1427
1428         vdec->aborting = true;
1429         vpu_iface_add_scode(inst, SCODE_PADDING_ABORT);
1430         vdec->params.end_flag = 1;
1431         vpu_iface_set_decode_params(inst, &vdec->params, 1);
1432
1433         vpu_session_abort(inst);
1434
1435         ret = vpu_iface_get_stream_buffer_desc(inst, &desc);
1436         if (!ret)
1437                 vpu_iface_update_stream_buffer(inst, desc.rptr, 1);
1438
1439         vpu_session_rst_buf(inst);
1440         vpu_trace(inst->dev, "[%d] input : %d, decoded : %d, display : %d, sequence : %d\n",
1441                   inst->id,
1442                   vdec->params.frame_count,
1443                   vdec->decoded_frame_count,
1444                   vdec->display_frame_count,
1445                   vdec->sequence);
1446         if (!vdec->seq_hdr_found)
1447                 vdec->reset_codec = true;
1448         vdec->params.end_flag = 0;
1449         vdec->drain = 0;
1450         vdec->params.frame_count = 0;
1451         vdec->decoded_frame_count = 0;
1452         vdec->display_frame_count = 0;
1453         vdec->sequence = 0;
1454         vdec->aborting = false;
1455         inst->extra_size = 0;
1456 }
1457
1458 static void vdec_stop(struct vpu_inst *inst, bool free)
1459 {
1460         struct vdec_t *vdec = inst->priv;
1461
1462         vdec_clear_slots(inst);
1463         if (inst->state != VPU_CODEC_STATE_DEINIT)
1464                 vpu_session_stop(inst);
1465         vdec_clear_fs(&vdec->mbi);
1466         vdec_clear_fs(&vdec->dcp);
1467         if (free) {
1468                 vpu_free_dma(&vdec->udata);
1469                 vpu_free_dma(&inst->stream_buffer);
1470         }
1471         vdec_update_state(inst, VPU_CODEC_STATE_DEINIT, 1);
1472         vdec->reset_codec = false;
1473 }
1474
1475 static void vdec_release(struct vpu_inst *inst)
1476 {
1477         if (inst->id != VPU_INST_NULL_ID)
1478                 vpu_trace(inst->dev, "[%d]\n", inst->id);
1479         vdec_stop(inst, true);
1480 }
1481
1482 static void vdec_cleanup(struct vpu_inst *inst)
1483 {
1484         struct vdec_t *vdec;
1485
1486         if (!inst)
1487                 return;
1488
1489         vdec = inst->priv;
1490         vfree(vdec);
1491         inst->priv = NULL;
1492         vfree(inst);
1493 }
1494
1495 static void vdec_init_params(struct vdec_t *vdec)
1496 {
1497         vdec->params.frame_count = 0;
1498         vdec->params.end_flag = 0;
1499 }
1500
1501 static int vdec_start(struct vpu_inst *inst)
1502 {
1503         struct vdec_t *vdec = inst->priv;
1504         int stream_buffer_size;
1505         int ret;
1506
1507         if (inst->state != VPU_CODEC_STATE_DEINIT)
1508                 return 0;
1509
1510         vpu_trace(inst->dev, "[%d]\n", inst->id);
1511         if (!vdec->udata.virt) {
1512                 vdec->udata.length = 0x1000;
1513                 ret = vpu_alloc_dma(inst->core, &vdec->udata);
1514                 if (ret) {
1515                         dev_err(inst->dev, "[%d] alloc udata fail\n", inst->id);
1516                         goto error;
1517                 }
1518         }
1519
1520         if (!inst->stream_buffer.virt) {
1521                 stream_buffer_size = vpu_iface_get_stream_buffer_size(inst->core);
1522                 if (stream_buffer_size > 0) {
1523                         inst->stream_buffer.length = stream_buffer_size;
1524                         ret = vpu_alloc_dma(inst->core, &inst->stream_buffer);
1525                         if (ret) {
1526                                 dev_err(inst->dev, "[%d] alloc stream buffer fail\n", inst->id);
1527                                 goto error;
1528                         }
1529                         inst->use_stream_buffer = true;
1530                 }
1531         }
1532
1533         if (inst->use_stream_buffer)
1534                 vpu_iface_config_stream_buffer(inst, &inst->stream_buffer);
1535         vpu_iface_init_instance(inst);
1536         vdec->params.udata.base = vdec->udata.phys;
1537         vdec->params.udata.size = vdec->udata.length;
1538         ret = vpu_iface_set_decode_params(inst, &vdec->params, 0);
1539         if (ret) {
1540                 dev_err(inst->dev, "[%d] set decode params fail\n", inst->id);
1541                 goto error;
1542         }
1543
1544         vdec_init_params(vdec);
1545         ret = vpu_session_start(inst);
1546         if (ret) {
1547                 dev_err(inst->dev, "[%d] start fail\n", inst->id);
1548                 goto error;
1549         }
1550
1551         vdec_update_state(inst, VPU_CODEC_STATE_STARTED, 0);
1552
1553         return 0;
1554 error:
1555         vpu_free_dma(&vdec->udata);
1556         vpu_free_dma(&inst->stream_buffer);
1557         return ret;
1558 }
1559
1560 static int vdec_start_session(struct vpu_inst *inst, u32 type)
1561 {
1562         struct vdec_t *vdec = inst->priv;
1563         int ret = 0;
1564
1565         if (V4L2_TYPE_IS_OUTPUT(type)) {
1566                 if (vdec->reset_codec)
1567                         vdec_stop(inst, false);
1568                 if (inst->state == VPU_CODEC_STATE_DEINIT) {
1569                         ret = vdec_start(inst);
1570                         if (ret)
1571                                 return ret;
1572                 }
1573         }
1574
1575         if (V4L2_TYPE_IS_OUTPUT(type)) {
1576                 vdec_update_state(inst, vdec->state, 1);
1577                 vdec->eos_received = 0;
1578                 vpu_process_output_buffer(inst);
1579         } else {
1580                 vdec_cmd_start(inst);
1581         }
1582         if (inst->state == VPU_CODEC_STATE_ACTIVE)
1583                 vdec_response_fs_request(inst, false);
1584
1585         return ret;
1586 }
1587
1588 static int vdec_stop_session(struct vpu_inst *inst, u32 type)
1589 {
1590         struct vdec_t *vdec = inst->priv;
1591
1592         if (inst->state == VPU_CODEC_STATE_DEINIT)
1593                 return 0;
1594
1595         if (V4L2_TYPE_IS_OUTPUT(type)) {
1596                 vdec_update_state(inst, VPU_CODEC_STATE_SEEK, 0);
1597                 vdec->drain = 0;
1598         } else {
1599                 if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE) {
1600                         vdec_abort(inst);
1601                         vdec->eos_received = 0;
1602                 }
1603                 vdec_clear_slots(inst);
1604         }
1605
1606         return 0;
1607 }
1608
1609 static int vdec_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i)
1610 {
1611         struct vdec_t *vdec = inst->priv;
1612         int num = -1;
1613
1614         switch (i) {
1615         case 0:
1616                 num = scnprintf(str, size,
1617                                 "req_frame_count = %d\ninterlaced = %d\n",
1618                                 vdec->req_frame_count,
1619                                 vdec->codec_info.progressive ? 0 : 1);
1620                 break;
1621         case 1:
1622                 num = scnprintf(str, size,
1623                                 "mbi: size = 0x%x request = %d, alloc = %d, response = %d\n",
1624                                 vdec->mbi.size,
1625                                 vdec->mbi.req_count,
1626                                 vdec->mbi.count,
1627                                 vdec->mbi.index);
1628                 break;
1629         case 2:
1630                 num = scnprintf(str, size,
1631                                 "dcp: size = 0x%x request = %d, alloc = %d, response = %d\n",
1632                                 vdec->dcp.size,
1633                                 vdec->dcp.req_count,
1634                                 vdec->dcp.count,
1635                                 vdec->dcp.index);
1636                 break;
1637         case 3:
1638                 num = scnprintf(str, size, "input_frame_count = %d\n", vdec->params.frame_count);
1639                 break;
1640         case 4:
1641                 num = scnprintf(str, size, "decoded_frame_count = %d\n", vdec->decoded_frame_count);
1642                 break;
1643         case 5:
1644                 num = scnprintf(str, size, "display_frame_count = %d\n", vdec->display_frame_count);
1645                 break;
1646         case 6:
1647                 num = scnprintf(str, size, "sequence = %d\n", vdec->sequence);
1648                 break;
1649         case 7:
1650                 num = scnprintf(str, size, "drain = %d, eos = %d, source_change = %d\n",
1651                                 vdec->drain, vdec->eos_received, vdec->source_change);
1652                 break;
1653         case 8:
1654                 num = scnprintf(str, size, "fps = %d/%d\n",
1655                                 vdec->codec_info.frame_rate.numerator,
1656                                 vdec->codec_info.frame_rate.denominator);
1657                 break;
1658         case 9:
1659                 num = scnprintf(str, size, "colorspace: %d, %d, %d, %d (%d)\n",
1660                                 vdec->codec_info.color_primaries,
1661                                 vdec->codec_info.transfer_chars,
1662                                 vdec->codec_info.matrix_coeffs,
1663                                 vdec->codec_info.full_range,
1664                                 vdec->codec_info.vui_present);
1665                 break;
1666         default:
1667                 break;
1668         }
1669
1670         return num;
1671 }
1672
1673 static struct vpu_inst_ops vdec_inst_ops = {
1674         .ctrl_init = vdec_ctrl_init,
1675         .check_ready = vdec_check_ready,
1676         .buf_done = vdec_buf_done,
1677         .get_one_frame = vdec_frame_decoded,
1678         .stop_done = vdec_stop_done,
1679         .event_notify = vdec_event_notify,
1680         .release = vdec_release,
1681         .cleanup = vdec_cleanup,
1682         .start = vdec_start_session,
1683         .stop = vdec_stop_session,
1684         .process_output = vdec_process_output,
1685         .process_capture = vdec_process_capture,
1686         .on_queue_empty = vdec_on_queue_empty,
1687         .get_debug_info = vdec_get_debug_info,
1688         .wait_prepare = vpu_inst_unlock,
1689         .wait_finish = vpu_inst_lock,
1690 };
1691
1692 static void vdec_init(struct file *file)
1693 {
1694         struct vpu_inst *inst = to_inst(file);
1695         struct v4l2_format f;
1696
1697         memset(&f, 0, sizeof(f));
1698         f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1699         f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
1700         f.fmt.pix_mp.width = 1280;
1701         f.fmt.pix_mp.height = 720;
1702         f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1703         vdec_s_fmt(file, &inst->fh, &f);
1704
1705         memset(&f, 0, sizeof(f));
1706         f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1707         f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M_8L128;
1708         f.fmt.pix_mp.width = 1280;
1709         f.fmt.pix_mp.height = 720;
1710         f.fmt.pix_mp.field = V4L2_FIELD_NONE;
1711         vdec_s_fmt(file, &inst->fh, &f);
1712 }
1713
1714 static int vdec_open(struct file *file)
1715 {
1716         struct vpu_inst *inst;
1717         struct vdec_t *vdec;
1718         int ret;
1719
1720         inst = vzalloc(sizeof(*inst));
1721         if (!inst)
1722                 return -ENOMEM;
1723
1724         vdec = vzalloc(sizeof(*vdec));
1725         if (!vdec) {
1726                 vfree(inst);
1727                 return -ENOMEM;
1728         }
1729
1730         inst->ops = &vdec_inst_ops;
1731         inst->formats = vdec_formats;
1732         inst->type = VPU_CORE_TYPE_DEC;
1733         inst->priv = vdec;
1734
1735         ret = vpu_v4l2_open(file, inst);
1736         if (ret)
1737                 return ret;
1738
1739         vdec->fixed_fmt = false;
1740         vdec->state = VPU_CODEC_STATE_ACTIVE;
1741         inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP;
1742         inst->min_buffer_out = VDEC_MIN_BUFFER_OUT;
1743         vdec_init(file);
1744
1745         return 0;
1746 }
1747
1748 static const struct v4l2_file_operations vdec_fops = {
1749         .owner = THIS_MODULE,
1750         .open = vdec_open,
1751         .release = vpu_v4l2_close,
1752         .unlocked_ioctl = video_ioctl2,
1753         .poll = v4l2_m2m_fop_poll,
1754         .mmap = v4l2_m2m_fop_mmap,
1755 };
1756
1757 const struct v4l2_ioctl_ops *vdec_get_ioctl_ops(void)
1758 {
1759         return &vdec_ioctl_ops;
1760 }
1761
1762 const struct v4l2_file_operations *vdec_get_fops(void)
1763 {
1764         return &vdec_fops;
1765 }