drivers/media/platform/mediatek/vcodec/vdec/vdec_vp8_if.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016 MediaTek Inc.
   4  * Author: Jungchang Tsao <jungchang.tsao@mediatek.com>
   5  *         PC Chen <pc.chen@mediatek.com>
   6  */
   7
   8 #include <linux/slab.h>
   9 #include "../vdec_drv_if.h"
  10 #include "../mtk_vcodec_util.h"
  11 #include "../mtk_vcodec_dec.h"
  12 #include "../mtk_vcodec_intr.h"
  13 #include "../vdec_vpu_if.h"
  14 #include "../vdec_drv_base.h"
  15
  16 /* Decoding picture buffer size (3 reference frames plus current frame) */
  17 #define VP8_DPB_SIZE                    4
  18
  19 /* HW working buffer size (bytes) */
  20 #define VP8_WORKING_BUF_SZ              (45 * 4096)
  21
  22 /* HW control register address */
  23 #define VP8_SEGID_DRAM_ADDR             0x3c
  24 #define VP8_HW_VLD_ADDR                 0x93C
  25 #define VP8_HW_VLD_VALUE                0x940
  26 #define VP8_BSASET                      0x100
  27 #define VP8_BSDSET                      0x104
  28 #define VP8_RW_CKEN_SET                 0x0
  29 #define VP8_RW_DCM_CON                  0x18
  30 #define VP8_WO_VLD_SRST                 0x108
  31 #define VP8_RW_MISC_SYS_SEL             0x84
  32 #define VP8_RW_MISC_SPEC_CON            0xC8
  33 #define VP8_WO_VLD_SRST                 0x108
  34 #define VP8_RW_VP8_CTRL                 0xA4
  35 #define VP8_RW_MISC_DCM_CON             0xEC
  36 #define VP8_RW_MISC_SRST                0xF4
  37 #define VP8_RW_MISC_FUNC_CON            0xCC
  38
  39 #define VP8_MAX_FRM_BUF_NUM             5
  40 #define VP8_MAX_FRM_BUF_NODE_NUM        (VP8_MAX_FRM_BUF_NUM * 2)
  41
  42 /* required buffer size (bytes) to store decode information */
  43 #define VP8_HW_SEGMENT_DATA_SZ          272
  44 #define VP8_HW_SEGMENT_UINT             4
  45
  46 #define VP8_DEC_TABLE_PROC_LOOP         96
  47 #define VP8_DEC_TABLE_UNIT              3
  48 #define VP8_DEC_TABLE_SZ                300
  49 #define VP8_DEC_TABLE_OFFSET            2
  50 #define VP8_DEC_TABLE_RW_UNIT           4
  51
  52 /**
  53  * struct vdec_vp8_dec_info - decode misc information
  54  * @working_buf_dma   : working buffer dma address
  55  * @prev_y_dma        : previous decoded frame buffer Y plane address
  56  * @cur_y_fb_dma      : current plane Y frame buffer dma address
  57  * @cur_c_fb_dma      : current plane C frame buffer dma address
  58  * @bs_dma            : bitstream dma address
  59  * @bs_sz             : bitstream size
  60  * @resolution_changed: resolution change flag 1 - changed,  0 - not change
  61  * @show_frame        : display this frame or not
  62  * @wait_key_frame    : wait key frame coming
  63  */
  64 struct vdec_vp8_dec_info {
  65         uint64_t working_buf_dma;
  66         uint64_t prev_y_dma;
  67         uint64_t cur_y_fb_dma;
  68         uint64_t cur_c_fb_dma;
  69         uint64_t bs_dma;
  70         uint32_t bs_sz;
  71         uint32_t resolution_changed;
  72         uint32_t show_frame;
  73         uint32_t wait_key_frame;
  74 };
  75
  76 /**
  77  * struct vdec_vp8_vsi - VPU shared information
  78  * @dec                 : decoding information
  79  * @pic                 : picture information
  80  * @dec_table           : decoder coefficient table
  81  * @segment_buf         : segmentation buffer
  82  * @load_data           : flag to indicate reload decode data
  83  */
  84 struct vdec_vp8_vsi {
  85         struct vdec_vp8_dec_info dec;
  86         struct vdec_pic_info pic;
  87         uint32_t dec_table[VP8_DEC_TABLE_SZ];
  88         uint32_t segment_buf[VP8_HW_SEGMENT_DATA_SZ][VP8_HW_SEGMENT_UINT];
  89         uint32_t load_data;
  90 };
  91
  92 /**
  93  * struct vdec_vp8_hw_reg_base - HW register base
  94  * @misc        : base address for misc
  95  * @ld          : base address for ld
  96  * @top         : base address for top
  97  * @cm          : base address for cm
  98  * @hwd         : base address for hwd
  99  * @hwb         : base address for hwb
 100  */
 101 struct vdec_vp8_hw_reg_base {
 102         void __iomem *misc;
 103         void __iomem *ld;
 104         void __iomem *top;
 105         void __iomem *cm;
 106         void __iomem *hwd;
 107         void __iomem *hwb;
 108 };
 109
 110 /**
 111  * struct vdec_vp8_vpu_inst - VPU instance for VP8 decode
 112  * @wq_hd       : Wait queue to wait VPU message ack
 113  * @signaled    : 1 - Host has received ack message from VPU, 0 - not receive
 114  * @failure     : VPU execution result status 0 - success, others - fail
 115  * @inst_addr   : VPU decoder instance address
 116  */
 117 struct vdec_vp8_vpu_inst {
 118         wait_queue_head_t wq_hd;
 119         int signaled;
 120         int failure;
 121         uint32_t inst_addr;
 122 };
 123
 124 /* frame buffer (fb) list
 125  * [available_fb_node_list]  - decode fb are initialized to 0 and populated in
 126  * [fb_use_list]  - fb is set after decode and is moved to this list
 127  * [fb_free_list] - fb is not needed for reference will be moved from
 128  *                   [fb_use_list] to [fb_free_list] and
 129  *                   once user remove fb from [fb_free_list],
 130  *                   it is circulated back to [available_fb_node_list]
 131  * [fb_disp_list] - fb is set after decode and is moved to this list
 132  *                   once user remove fb from [fb_disp_list] it is
 133  *                   circulated back to [available_fb_node_list]
 134  */
 135
 136 /**
 137  * struct vdec_vp8_inst - VP8 decoder instance
 138  * @cur_fb                 : current frame buffer
 139  * @dec_fb                 : decode frame buffer node
 140  * @available_fb_node_list : list to store available frame buffer node
 141  * @fb_use_list            : list to store frame buffer in use
 142  * @fb_free_list           : list to store free frame buffer
 143  * @fb_disp_list           : list to store display ready frame buffer
 144  * @working_buf            : HW decoder working buffer
 145  * @reg_base               : HW register base address
 146  * @frm_cnt                : decode frame count
 147  * @ctx                    : V4L2 context
 148  * @vpu                    : VPU instance for decoder
 149  * @vsi                    : VPU share information
 150  */
 151 struct vdec_vp8_inst {
 152         struct vdec_fb *cur_fb;
 153         struct vdec_fb_node dec_fb[VP8_MAX_FRM_BUF_NODE_NUM];
 154         struct list_head available_fb_node_list;
 155         struct list_head fb_use_list;
 156         struct list_head fb_free_list;
 157         struct list_head fb_disp_list;
 158         struct mtk_vcodec_mem working_buf;
 159         struct vdec_vp8_hw_reg_base reg_base;
 160         unsigned int frm_cnt;
 161         struct mtk_vcodec_dec_ctx *ctx;
 162         struct vdec_vpu_inst vpu;
 163         struct vdec_vp8_vsi *vsi;
 164 };
 165
 166 static void get_hw_reg_base(struct vdec_vp8_inst *inst)
 167 {
 168         void __iomem **reg_base = inst->ctx->dev->reg_base;
 169
 170         inst->reg_base.top = mtk_vcodec_get_reg_addr(reg_base, VDEC_TOP);
 171         inst->reg_base.cm = mtk_vcodec_get_reg_addr(reg_base, VDEC_CM);
 172         inst->reg_base.hwd = mtk_vcodec_get_reg_addr(reg_base, VDEC_HWD);
 173         inst->reg_base.misc = mtk_vcodec_get_reg_addr(reg_base, VDEC_MISC);
 174         inst->reg_base.ld = mtk_vcodec_get_reg_addr(reg_base, VDEC_LD);
 175         inst->reg_base.hwb = mtk_vcodec_get_reg_addr(reg_base, VDEC_HWB);
 176 }
 177
 178 static void write_hw_segmentation_data(struct vdec_vp8_inst *inst)
 179 {
 180         int i, j;
 181         u32 seg_id_addr;
 182         u32 val;
 183         void __iomem *cm = inst->reg_base.cm;
 184         struct vdec_vp8_vsi *vsi = inst->vsi;
 185
 186         seg_id_addr = readl(inst->reg_base.top + VP8_SEGID_DRAM_ADDR) >> 4;
 187
 188         for (i = 0; i < ARRAY_SIZE(vsi->segment_buf); i++) {
 189                 for (j = ARRAY_SIZE(vsi->segment_buf[i]) - 1; j >= 0; j--) {
 190                         val = (1 << 16) + ((seg_id_addr + i) << 2) + j;
 191                         writel(val, cm + VP8_HW_VLD_ADDR);
 192
 193                         val = vsi->segment_buf[i][j];
 194                         writel(val, cm + VP8_HW_VLD_VALUE);
 195                 }
 196         }
 197 }
 198
 199 static void read_hw_segmentation_data(struct vdec_vp8_inst *inst)
 200 {
 201         int i, j;
 202         u32 seg_id_addr;
 203         u32 val;
 204         void __iomem *cm = inst->reg_base.cm;
 205         struct vdec_vp8_vsi *vsi = inst->vsi;
 206
 207         seg_id_addr = readl(inst->reg_base.top + VP8_SEGID_DRAM_ADDR) >> 4;
 208
 209         for (i = 0; i < ARRAY_SIZE(vsi->segment_buf); i++) {
 210                 for (j = ARRAY_SIZE(vsi->segment_buf[i]) - 1; j >= 0; j--) {
 211                         val = ((seg_id_addr + i) << 2) + j;
 212                         writel(val, cm + VP8_HW_VLD_ADDR);
 213
 214                         val = readl(cm + VP8_HW_VLD_VALUE);
 215                         vsi->segment_buf[i][j] = val;
 216                 }
 217         }
 218 }
 219
 220 /* reset HW and enable HW read/write data function */
 221 static void enable_hw_rw_function(struct vdec_vp8_inst *inst)
 222 {
 223         u32 val = 0;
 224         void __iomem *misc = inst->reg_base.misc;
 225         void __iomem *ld = inst->reg_base.ld;
 226         void __iomem *hwb = inst->reg_base.hwb;
 227         void __iomem *hwd = inst->reg_base.hwd;
 228
 229         mtk_vcodec_write_vdecsys(inst->ctx, VP8_RW_CKEN_SET, 0x1);
 230         writel(0x101, ld + VP8_WO_VLD_SRST);
 231         writel(0x101, hwb + VP8_WO_VLD_SRST);
 232
 233         mtk_vcodec_write_vdecsys(inst->ctx, 0, 0x1);
 234         val = readl(misc + VP8_RW_MISC_SRST);
 235         writel((val & 0xFFFFFFFE), misc + VP8_RW_MISC_SRST);
 236
 237         writel(0x1, misc + VP8_RW_MISC_SYS_SEL);
 238         writel(0x17F, misc + VP8_RW_MISC_SPEC_CON);
 239         writel(0x71201100, misc + VP8_RW_MISC_FUNC_CON);
 240         writel(0x0, ld + VP8_WO_VLD_SRST);
 241         writel(0x0, hwb + VP8_WO_VLD_SRST);
 242         mtk_vcodec_write_vdecsys(inst->ctx, VP8_RW_DCM_CON, 0x1);
 243         writel(0x1, misc + VP8_RW_MISC_DCM_CON);
 244         writel(0x1, hwd + VP8_RW_VP8_CTRL);
 245 }
 246
 247 static void store_dec_table(struct vdec_vp8_inst *inst)
 248 {
 249         int i, j;
 250         u32 addr = 0, val = 0;
 251         void __iomem *hwd = inst->reg_base.hwd;
 252         u32 *p = &inst->vsi->dec_table[VP8_DEC_TABLE_OFFSET];
 253
 254         for (i = 0; i < VP8_DEC_TABLE_PROC_LOOP; i++) {
 255                 writel(addr, hwd + VP8_BSASET);
 256                 for (j = 0; j < VP8_DEC_TABLE_UNIT ; j++) {
 257                         val = *p++;
 258                         writel(val, hwd + VP8_BSDSET);
 259                 }
 260                 addr += VP8_DEC_TABLE_RW_UNIT;
 261         }
 262 }
 263
 264 static void load_dec_table(struct vdec_vp8_inst *inst)
 265 {
 266         int i;
 267         u32 addr = 0;
 268         u32 *p = &inst->vsi->dec_table[VP8_DEC_TABLE_OFFSET];
 269         void __iomem *hwd = inst->reg_base.hwd;
 270
 271         for (i = 0; i < VP8_DEC_TABLE_PROC_LOOP; i++) {
 272                 writel(addr, hwd + VP8_BSASET);
 273                 /* read total 11 bytes */
 274                 *p++ = readl(hwd + VP8_BSDSET);
 275                 *p++ = readl(hwd + VP8_BSDSET);
 276                 *p++ = readl(hwd + VP8_BSDSET) & 0xFFFFFF;
 277                 addr += VP8_DEC_TABLE_RW_UNIT;
 278         }
 279 }
 280
 281 static void get_pic_info(struct vdec_vp8_inst *inst, struct vdec_pic_info *pic)
 282 {
 283         *pic = inst->vsi->pic;
 284
 285         mtk_vdec_debug(inst->ctx, "pic(%d, %d), buf(%d, %d)",
 286                        pic->pic_w, pic->pic_h, pic->buf_w, pic->buf_h);
 287         mtk_vdec_debug(inst->ctx, "fb size: Y(%d), C(%d)",
 288                        pic->fb_sz[0], pic->fb_sz[1]);
 289 }
 290
 291 static void vp8_dec_finish(struct vdec_vp8_inst *inst)
 292 {
 293         struct vdec_fb_node *node;
 294         uint64_t prev_y_dma = inst->vsi->dec.prev_y_dma;
 295
 296         mtk_vdec_debug(inst->ctx, "prev fb base dma=%llx", prev_y_dma);
 297
 298         /* put last decode ok frame to fb_free_list */
 299         if (prev_y_dma != 0) {
 300                 list_for_each_entry(node, &inst->fb_use_list, list) {
 301                         struct vdec_fb *fb = (struct vdec_fb *)node->fb;
 302
 303                         if (prev_y_dma == (uint64_t)fb->base_y.dma_addr) {
 304                                 list_move_tail(&node->list,
 305                                                &inst->fb_free_list);
 306                                 break;
 307                         }
 308                 }
 309         }
 310
 311         /* available_fb_node_list -> fb_use_list */
 312         node = list_first_entry(&inst->available_fb_node_list,
 313                                 struct vdec_fb_node, list);
 314         node->fb = inst->cur_fb;
 315         list_move_tail(&node->list, &inst->fb_use_list);
 316
 317         /* available_fb_node_list -> fb_disp_list */
 318         if (inst->vsi->dec.show_frame) {
 319                 node = list_first_entry(&inst->available_fb_node_list,
 320                                         struct vdec_fb_node, list);
 321                 node->fb = inst->cur_fb;
 322                 list_move_tail(&node->list, &inst->fb_disp_list);
 323         }
 324 }
 325
 326 static void move_fb_list_use_to_free(struct vdec_vp8_inst *inst)
 327 {
 328         struct vdec_fb_node *node, *tmp;
 329
 330         list_for_each_entry_safe(node, tmp, &inst->fb_use_list, list)
 331                 list_move_tail(&node->list, &inst->fb_free_list);
 332 }
 333
 334 static void init_list(struct vdec_vp8_inst *inst)
 335 {
 336         int i;
 337
 338         INIT_LIST_HEAD(&inst->available_fb_node_list);
 339         INIT_LIST_HEAD(&inst->fb_use_list);
 340         INIT_LIST_HEAD(&inst->fb_free_list);
 341         INIT_LIST_HEAD(&inst->fb_disp_list);
 342
 343         for (i = 0; i < ARRAY_SIZE(inst->dec_fb); i++) {
 344                 INIT_LIST_HEAD(&inst->dec_fb[i].list);
 345                 inst->dec_fb[i].fb = NULL;
 346                 list_add_tail(&inst->dec_fb[i].list,
 347                               &inst->available_fb_node_list);
 348         }
 349 }
 350
 351 static void add_fb_to_free_list(struct vdec_vp8_inst *inst, void *fb)
 352 {
 353         struct vdec_fb_node *node;
 354
 355         if (fb) {
 356                 node = list_first_entry(&inst->available_fb_node_list,
 357                                         struct vdec_fb_node, list);
 358                 node->fb = fb;
 359                 list_move_tail(&node->list, &inst->fb_free_list);
 360         }
 361 }
 362
 363 static int alloc_working_buf(struct vdec_vp8_inst *inst)
 364 {
 365         int err;
 366         struct mtk_vcodec_mem *mem = &inst->working_buf;
 367
 368         mem->size = VP8_WORKING_BUF_SZ;
 369         err = mtk_vcodec_mem_alloc(inst->ctx, mem);
 370         if (err) {
 371                 mtk_vdec_err(inst->ctx, "Cannot allocate working buffer");
 372                 return err;
 373         }
 374
 375         inst->vsi->dec.working_buf_dma = (uint64_t)mem->dma_addr;
 376         return 0;
 377 }
 378
 379 static void free_working_buf(struct vdec_vp8_inst *inst)
 380 {
 381         struct mtk_vcodec_mem *mem = &inst->working_buf;
 382
 383         if (mem->va)
 384                 mtk_vcodec_mem_free(inst->ctx, mem);
 385
 386         inst->vsi->dec.working_buf_dma = 0;
 387 }
 388
 389 static int vdec_vp8_init(struct mtk_vcodec_dec_ctx *ctx)
 390 {
 391         struct vdec_vp8_inst *inst;
 392         int err;
 393
 394         inst = kzalloc(sizeof(*inst), GFP_KERNEL);
 395         if (!inst)
 396                 return  -ENOMEM;
 397
 398         inst->ctx = ctx;
 399
 400         inst->vpu.id = IPI_VDEC_VP8;
 401         inst->vpu.ctx = ctx;
 402
 403         err = vpu_dec_init(&inst->vpu);
 404         if (err) {
 405                 mtk_vdec_err(ctx, "vdec_vp8 init err=%d", err);
 406                 goto error_free_inst;
 407         }
 408
 409         inst->vsi = (struct vdec_vp8_vsi *)inst->vpu.vsi;
 410         init_list(inst);
 411         err = alloc_working_buf(inst);
 412         if (err)
 413                 goto error_deinit;
 414
 415         get_hw_reg_base(inst);
 416         mtk_vdec_debug(ctx, "VP8 Instance >> %p", inst);
 417
 418         ctx->drv_handle = inst;
 419         return 0;
 420
 421 error_deinit:
 422         vpu_dec_deinit(&inst->vpu);
 423 error_free_inst:
 424         kfree(inst);
 425         return err;
 426 }
 427
 428 static int vdec_vp8_decode(void *h_vdec, struct mtk_vcodec_mem *bs,
 429                            struct vdec_fb *fb, bool *res_chg)
 430 {
 431         struct vdec_vp8_inst *inst = (struct vdec_vp8_inst *)h_vdec;
 432         struct vdec_vp8_dec_info *dec = &inst->vsi->dec;
 433         struct vdec_vpu_inst *vpu = &inst->vpu;
 434         unsigned char *bs_va;
 435         unsigned int data;
 436         int err = 0;
 437         uint64_t y_fb_dma;
 438         uint64_t c_fb_dma;
 439
 440         /* bs NULL means flush decoder */
 441         if (bs == NULL) {
 442                 move_fb_list_use_to_free(inst);
 443                 return vpu_dec_reset(vpu);
 444         }
 445
 446         y_fb_dma = fb ? (u64)fb->base_y.dma_addr : 0;
 447         c_fb_dma = fb ? (u64)fb->base_c.dma_addr : 0;
 448
 449         mtk_vdec_debug(inst->ctx, "+ [%d] FB y_dma=%llx c_dma=%llx fb=%p",
 450                        inst->frm_cnt, y_fb_dma, c_fb_dma, fb);
 451
 452         inst->cur_fb = fb;
 453         dec->bs_dma = (unsigned long)bs->dma_addr;
 454         dec->bs_sz = bs->size;
 455         dec->cur_y_fb_dma = y_fb_dma;
 456         dec->cur_c_fb_dma = c_fb_dma;
 457
 458         mtk_vdec_debug(inst->ctx, "\n + FRAME[%d] +\n", inst->frm_cnt);
 459
 460         write_hw_segmentation_data(inst);
 461         enable_hw_rw_function(inst);
 462         store_dec_table(inst);
 463
 464         bs_va = (unsigned char *)bs->va;
 465
 466         /* retrieve width/hight and scale info from header */
 467         data = (*(bs_va + 9) << 24) | (*(bs_va + 8) << 16) |
 468                (*(bs_va + 7) << 8) | *(bs_va + 6);
 469         err = vpu_dec_start(vpu, &data, 1);
 470         if (err) {
 471                 add_fb_to_free_list(inst, fb);
 472                 if (dec->wait_key_frame) {
 473                         mtk_vdec_debug(inst->ctx, "wait key frame !");
 474                         return 0;
 475                 }
 476
 477                 goto error;
 478         }
 479
 480         if (dec->resolution_changed) {
 481                 mtk_vdec_debug(inst->ctx, "- resolution_changed -");
 482                 *res_chg = true;
 483                 add_fb_to_free_list(inst, fb);
 484                 return 0;
 485         }
 486
 487         /* wait decoder done interrupt */
 488         mtk_vcodec_wait_for_done_ctx(inst->ctx, MTK_INST_IRQ_RECEIVED,
 489                                      WAIT_INTR_TIMEOUT_MS, 0);
 490
 491         if (inst->vsi->load_data)
 492                 load_dec_table(inst);
 493
 494         vp8_dec_finish(inst);
 495         read_hw_segmentation_data(inst);
 496
 497         err = vpu_dec_end(vpu);
 498         if (err)
 499                 goto error;
 500
 501         mtk_vdec_debug(inst->ctx, "\n - FRAME[%d] - show=%d\n", inst->frm_cnt, dec->show_frame);
 502         inst->frm_cnt++;
 503         *res_chg = false;
 504         return 0;
 505
 506 error:
 507         mtk_vdec_err(inst->ctx, "\n - FRAME[%d] - err=%d\n", inst->frm_cnt, err);
 508         return err;
 509 }
 510
 511 static void get_disp_fb(struct vdec_vp8_inst *inst, struct vdec_fb **out_fb)
 512 {
 513         struct vdec_fb_node *node;
 514         struct vdec_fb *fb;
 515
 516         node = list_first_entry_or_null(&inst->fb_disp_list,
 517                                         struct vdec_fb_node, list);
 518         if (node) {
 519                 list_move_tail(&node->list, &inst->available_fb_node_list);
 520                 fb = (struct vdec_fb *)node->fb;
 521                 fb->status |= FB_ST_DISPLAY;
 522                 mtk_vdec_debug(inst->ctx, "[FB] get disp fb %p st=%d", node->fb, fb->status);
 523         } else {
 524                 fb = NULL;
 525                 mtk_vdec_debug(inst->ctx, "[FB] there is no disp fb");
 526         }
 527
 528         *out_fb = fb;
 529 }
 530
 531 static void get_free_fb(struct vdec_vp8_inst *inst, struct vdec_fb **out_fb)
 532 {
 533         struct vdec_fb_node *node;
 534         struct vdec_fb *fb;
 535
 536         node = list_first_entry_or_null(&inst->fb_free_list,
 537                                         struct vdec_fb_node, list);
 538         if (node) {
 539                 list_move_tail(&node->list, &inst->available_fb_node_list);
 540                 fb = (struct vdec_fb *)node->fb;
 541                 fb->status |= FB_ST_FREE;
 542                 mtk_vdec_debug(inst->ctx, "[FB] get free fb %p st=%d", node->fb, fb->status);
 543         } else {
 544                 fb = NULL;
 545                 mtk_vdec_debug(inst->ctx, "[FB] there is no free fb");
 546         }
 547
 548         *out_fb = fb;
 549 }
 550
 551 static void get_crop_info(struct vdec_vp8_inst *inst, struct v4l2_rect *cr)
 552 {
 553         cr->left = 0;
 554         cr->top = 0;
 555         cr->width = inst->vsi->pic.pic_w;
 556         cr->height = inst->vsi->pic.pic_h;
 557         mtk_vdec_debug(inst->ctx, "get crop info l=%d, t=%d, w=%d, h=%d",
 558                        cr->left, cr->top, cr->width, cr->height);
 559 }
 560
 561 static int vdec_vp8_get_param(void *h_vdec, enum vdec_get_param_type type,
 562                               void *out)
 563 {
 564         struct vdec_vp8_inst *inst = (struct vdec_vp8_inst *)h_vdec;
 565
 566         switch (type) {
 567         case GET_PARAM_DISP_FRAME_BUFFER:
 568                 get_disp_fb(inst, out);
 569                 break;
 570
 571         case GET_PARAM_FREE_FRAME_BUFFER:
 572                 get_free_fb(inst, out);
 573                 break;
 574
 575         case GET_PARAM_PIC_INFO:
 576                 get_pic_info(inst, out);
 577                 break;
 578
 579         case GET_PARAM_CROP_INFO:
 580                 get_crop_info(inst, out);
 581                 break;
 582
 583         case GET_PARAM_DPB_SIZE:
 584                 *((unsigned int *)out) = VP8_DPB_SIZE;
 585                 break;
 586
 587         default:
 588                 mtk_vdec_err(inst->ctx, "invalid get parameter type=%d", type);
 589                 return -EINVAL;
 590         }
 591
 592         return 0;
 593 }
 594
 595 static void vdec_vp8_deinit(void *h_vdec)
 596 {
 597         struct vdec_vp8_inst *inst = (struct vdec_vp8_inst *)h_vdec;
 598
 599         vpu_dec_deinit(&inst->vpu);
 600         free_working_buf(inst);
 601         kfree(inst);
 602 }
 603
 604 const struct vdec_common_if vdec_vp8_if = {
 605         .init           = vdec_vp8_init,
 606         .decode         = vdec_vp8_decode,
 607         .get_param      = vdec_vp8_get_param,
 608         .deinit         = vdec_vp8_deinit,
 609 };