1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (c) 2021 MediaTek Inc. 4 * Author: Yunfei Dong <yunfei.dong@mediatek.com> 5 */ 6 7#include <linux/slab.h> 8#include <media/v4l2-mem2mem.h> 9#include <media/videobuf2-dma-contig.h> 10#include <uapi/linux/v4l2-controls.h> 11 12#include "../mtk_vcodec_dec.h" 13#include "../../common/mtk_vcodec_intr.h" 14#include "../vdec_drv_base.h" 15#include "../vdec_drv_if.h" 16#include "../vdec_vpu_if.h" 17 18/* Decoding picture buffer size (3 reference frames plus current frame) */ 19#define VP8_DPB_SIZE 4 20 21/* HW working buffer size (bytes) */ 22#define VP8_SEG_ID_SZ SZ_256K 23#define VP8_PP_WRAPY_SZ SZ_64K 24#define VP8_PP_WRAPC_SZ SZ_64K 25#define VP8_VLD_PRED_SZ SZ_64K 26 27/** 28 * struct vdec_vp8_slice_info - decode misc information 29 * 30 * @vld_wrapper_dma: vld wrapper dma address 31 * @seg_id_buf_dma: seg id dma address 32 * @wrap_y_dma: wrap y dma address 33 * @wrap_c_dma: wrap y dma address 34 * @cur_y_fb_dma: current plane Y frame buffer dma address 35 * @cur_c_fb_dma: current plane C frame buffer dma address 36 * @bs_dma: bitstream dma address 37 * @bs_sz: bitstream size 38 * @resolution_changed:resolution change flag 1 - changed, 0 - not change 39 * @frame_header_type: current frame header type 40 * @crc: used to check whether hardware's status is right 41 * @reserved: reserved, currently unused 42 */ 43struct vdec_vp8_slice_info { 44 u64 vld_wrapper_dma; 45 u64 seg_id_buf_dma; 46 u64 wrap_y_dma; 47 u64 wrap_c_dma; 48 u64 cur_y_fb_dma; 49 u64 cur_c_fb_dma; 50 u64 bs_dma; 51 u32 bs_sz; 52 u32 resolution_changed; 53 u32 frame_header_type; 54 u32 crc[8]; 55 u32 reserved; 56}; 57 58/** 59 * struct vdec_vp8_slice_dpb_info - vp8 reference information 60 * 61 * @y_dma_addr: Y bitstream physical address 62 * @c_dma_addr: CbCr bitstream physical address 63 * @reference_flag: reference picture flag 64 * @reserved: 64bit align 65 */ 66struct vdec_vp8_slice_dpb_info { 67 dma_addr_t y_dma_addr; 68 dma_addr_t c_dma_addr; 69 int reference_flag; 70 int reserved; 71}; 72 73/** 74 * struct vdec_vp8_slice_vsi - VPU shared information 75 * 76 * @dec: decoding information 77 * @pic: picture information 78 * @vp8_dpb_info: reference buffer information 79 */ 80struct vdec_vp8_slice_vsi { 81 struct vdec_vp8_slice_info dec; 82 struct vdec_pic_info pic; 83 struct vdec_vp8_slice_dpb_info vp8_dpb_info[3]; 84}; 85 86/** 87 * struct vdec_vp8_slice_inst - VP8 decoder instance 88 * 89 * @seg_id_buf: seg buffer 90 * @wrap_y_buf: wrapper y buffer 91 * @wrap_c_buf: wrapper c buffer 92 * @vld_wrapper_buf: vld wrapper buffer 93 * @ctx: V4L2 context 94 * @vpu: VPU instance for decoder 95 * @vsi: VPU share information 96 */ 97struct vdec_vp8_slice_inst { 98 struct mtk_vcodec_mem seg_id_buf; 99 struct mtk_vcodec_mem wrap_y_buf; 100 struct mtk_vcodec_mem wrap_c_buf; 101 struct mtk_vcodec_mem vld_wrapper_buf; 102 struct mtk_vcodec_dec_ctx *ctx; 103 struct vdec_vpu_inst vpu; 104 struct vdec_vp8_slice_vsi *vsi; 105}; 106 107static void *vdec_vp8_slice_get_ctrl_ptr(struct mtk_vcodec_dec_ctx *ctx, int id) 108{ 109 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl, id); 110 111 if (!ctrl) 112 return ERR_PTR(-EINVAL); 113 114 return ctrl->p_cur.p; 115} 116 117static void vdec_vp8_slice_get_pic_info(struct vdec_vp8_slice_inst *inst) 118{ 119 struct mtk_vcodec_dec_ctx *ctx = inst->ctx; 120 unsigned int data[3]; 121 122 data[0] = ctx->picinfo.pic_w; 123 data[1] = ctx->picinfo.pic_h; 124 data[2] = ctx->capture_fourcc; 125 vpu_dec_get_param(&inst->vpu, data, 3, GET_PARAM_PIC_INFO); 126 127 ctx->picinfo.buf_w = ALIGN(ctx->picinfo.pic_w, 64); 128 ctx->picinfo.buf_h = ALIGN(ctx->picinfo.pic_h, 64); 129 ctx->picinfo.fb_sz[0] = inst->vpu.fb_sz[0]; 130 ctx->picinfo.fb_sz[1] = inst->vpu.fb_sz[1]; 131 132 inst->vsi->pic.pic_w = ctx->picinfo.pic_w; 133 inst->vsi->pic.pic_h = ctx->picinfo.pic_h; 134 inst->vsi->pic.buf_w = ctx->picinfo.buf_w; 135 inst->vsi->pic.buf_h = ctx->picinfo.buf_h; 136 inst->vsi->pic.fb_sz[0] = ctx->picinfo.fb_sz[0]; 137 inst->vsi->pic.fb_sz[1] = ctx->picinfo.fb_sz[1]; 138 mtk_vdec_debug(inst->ctx, "pic(%d, %d), buf(%d, %d)", 139 ctx->picinfo.pic_w, ctx->picinfo.pic_h, 140 ctx->picinfo.buf_w, ctx->picinfo.buf_h); 141 mtk_vdec_debug(inst->ctx, "fb size: Y(%d), C(%d)", 142 ctx->picinfo.fb_sz[0], ctx->picinfo.fb_sz[1]); 143} 144 145static int vdec_vp8_slice_alloc_working_buf(struct vdec_vp8_slice_inst *inst) 146{ 147 int err; 148 struct mtk_vcodec_mem *mem; 149 150 mem = &inst->seg_id_buf; 151 mem->size = VP8_SEG_ID_SZ; 152 err = mtk_vcodec_mem_alloc(inst->ctx, mem); 153 if (err) { 154 mtk_vdec_err(inst->ctx, "Cannot allocate working buffer"); 155 return err; 156 } 157 inst->vsi->dec.seg_id_buf_dma = (u64)mem->dma_addr; 158 159 mem = &inst->wrap_y_buf; 160 mem->size = VP8_PP_WRAPY_SZ; 161 err = mtk_vcodec_mem_alloc(inst->ctx, mem); 162 if (err) { 163 mtk_vdec_err(inst->ctx, "cannot allocate WRAP Y buffer"); 164 return err; 165 } 166 inst->vsi->dec.wrap_y_dma = (u64)mem->dma_addr; 167 168 mem = &inst->wrap_c_buf; 169 mem->size = VP8_PP_WRAPC_SZ; 170 err = mtk_vcodec_mem_alloc(inst->ctx, mem); 171 if (err) { 172 mtk_vdec_err(inst->ctx, "cannot allocate WRAP C buffer"); 173 return err; 174 } 175 inst->vsi->dec.wrap_c_dma = (u64)mem->dma_addr; 176 177 mem = &inst->vld_wrapper_buf; 178 mem->size = VP8_VLD_PRED_SZ; 179 err = mtk_vcodec_mem_alloc(inst->ctx, mem); 180 if (err) { 181 mtk_vdec_err(inst->ctx, "cannot allocate vld wrapper buffer"); 182 return err; 183 } 184 inst->vsi->dec.vld_wrapper_dma = (u64)mem->dma_addr; 185 186 return 0; 187} 188 189static void vdec_vp8_slice_free_working_buf(struct vdec_vp8_slice_inst *inst) 190{ 191 struct mtk_vcodec_mem *mem; 192 193 mem = &inst->seg_id_buf; 194 if (mem->va) 195 mtk_vcodec_mem_free(inst->ctx, mem); 196 inst->vsi->dec.seg_id_buf_dma = 0; 197 198 mem = &inst->wrap_y_buf; 199 if (mem->va) 200 mtk_vcodec_mem_free(inst->ctx, mem); 201 inst->vsi->dec.wrap_y_dma = 0; 202 203 mem = &inst->wrap_c_buf; 204 if (mem->va) 205 mtk_vcodec_mem_free(inst->ctx, mem); 206 inst->vsi->dec.wrap_c_dma = 0; 207 208 mem = &inst->vld_wrapper_buf; 209 if (mem->va) 210 mtk_vcodec_mem_free(inst->ctx, mem); 211 inst->vsi->dec.vld_wrapper_dma = 0; 212} 213 214static u64 vdec_vp8_slice_get_ref_by_ts(const struct v4l2_ctrl_vp8_frame *frame_header, 215 int index) 216{ 217 switch (index) { 218 case 0: 219 return frame_header->last_frame_ts; 220 case 1: 221 return frame_header->golden_frame_ts; 222 case 2: 223 return frame_header->alt_frame_ts; 224 default: 225 break; 226 } 227 228 return -1; 229} 230 231static int vdec_vp8_slice_get_decode_parameters(struct vdec_vp8_slice_inst *inst) 232{ 233 const struct v4l2_ctrl_vp8_frame *frame_header; 234 struct mtk_vcodec_dec_ctx *ctx = inst->ctx; 235 struct vb2_queue *vq; 236 struct vb2_buffer *vb; 237 u64 referenct_ts; 238 int index; 239 240 frame_header = vdec_vp8_slice_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_VP8_FRAME); 241 if (IS_ERR(frame_header)) 242 return PTR_ERR(frame_header); 243 244 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 245 for (index = 0; index < 3; index++) { 246 referenct_ts = vdec_vp8_slice_get_ref_by_ts(frame_header, index); 247 vb = vb2_find_buffer(vq, referenct_ts); 248 if (!vb) { 249 if (!V4L2_VP8_FRAME_IS_KEY_FRAME(frame_header)) 250 mtk_vdec_err(inst->ctx, "reference invalid: index(%d) ts(%lld)", 251 index, referenct_ts); 252 inst->vsi->vp8_dpb_info[index].reference_flag = 0; 253 continue; 254 } 255 inst->vsi->vp8_dpb_info[index].reference_flag = 1; 256 257 inst->vsi->vp8_dpb_info[index].y_dma_addr = 258 vb2_dma_contig_plane_dma_addr(vb, 0); 259 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2) 260 inst->vsi->vp8_dpb_info[index].c_dma_addr = 261 vb2_dma_contig_plane_dma_addr(vb, 1); 262 else 263 inst->vsi->vp8_dpb_info[index].c_dma_addr = 264 inst->vsi->vp8_dpb_info[index].y_dma_addr + 265 ctx->picinfo.fb_sz[0]; 266 } 267 268 inst->vsi->dec.frame_header_type = frame_header->flags >> 1; 269 270 return 0; 271} 272 273static int vdec_vp8_slice_init(struct mtk_vcodec_dec_ctx *ctx) 274{ 275 struct vdec_vp8_slice_inst *inst; 276 int err; 277 278 inst = kzalloc(sizeof(*inst), GFP_KERNEL); 279 if (!inst) 280 return -ENOMEM; 281 282 inst->ctx = ctx; 283 284 inst->vpu.id = SCP_IPI_VDEC_LAT; 285 inst->vpu.core_id = SCP_IPI_VDEC_CORE; 286 inst->vpu.ctx = ctx; 287 inst->vpu.codec_type = ctx->current_codec; 288 inst->vpu.capture_type = ctx->capture_fourcc; 289 290 err = vpu_dec_init(&inst->vpu); 291 if (err) { 292 mtk_vdec_err(ctx, "vdec_vp8 init err=%d", err); 293 goto error_free_inst; 294 } 295 296 inst->vsi = inst->vpu.vsi; 297 err = vdec_vp8_slice_alloc_working_buf(inst); 298 if (err) 299 goto error_deinit; 300 301 mtk_vdec_debug(ctx, "vp8 struct size = %d vsi: %d\n", 302 (int)sizeof(struct v4l2_ctrl_vp8_frame), 303 (int)sizeof(struct vdec_vp8_slice_vsi)); 304 mtk_vdec_debug(ctx, "vp8:%p, codec_type = 0x%x vsi: 0x%p", 305 inst, inst->vpu.codec_type, inst->vpu.vsi); 306 307 ctx->drv_handle = inst; 308 return 0; 309 310error_deinit: 311 vpu_dec_deinit(&inst->vpu); 312error_free_inst: 313 kfree(inst); 314 return err; 315} 316 317static int vdec_vp8_slice_decode(void *h_vdec, struct mtk_vcodec_mem *bs, 318 struct vdec_fb *fb, bool *res_chg) 319{ 320 struct vdec_vp8_slice_inst *inst = h_vdec; 321 struct vdec_vpu_inst *vpu = &inst->vpu; 322 struct mtk_video_dec_buf *src_buf_info, *dst_buf_info; 323 unsigned int data; 324 u64 y_fb_dma, c_fb_dma; 325 int err, timeout; 326 327 /* Resolution changes are never initiated by us */ 328 *res_chg = false; 329 330 /* bs NULL means flush decoder */ 331 if (!bs) 332 return vpu_dec_reset(vpu); 333 334 src_buf_info = container_of(bs, struct mtk_video_dec_buf, bs_buffer); 335 336 fb = inst->ctx->dev->vdec_pdata->get_cap_buffer(inst->ctx); 337 dst_buf_info = container_of(fb, struct mtk_video_dec_buf, frame_buffer); 338 339 y_fb_dma = fb ? (u64)fb->base_y.dma_addr : 0; 340 if (inst->ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 1) 341 c_fb_dma = y_fb_dma + 342 inst->ctx->picinfo.buf_w * inst->ctx->picinfo.buf_h; 343 else 344 c_fb_dma = fb ? (u64)fb->base_c.dma_addr : 0; 345 346 inst->vsi->dec.bs_dma = (u64)bs->dma_addr; 347 inst->vsi->dec.bs_sz = bs->size; 348 inst->vsi->dec.cur_y_fb_dma = y_fb_dma; 349 inst->vsi->dec.cur_c_fb_dma = c_fb_dma; 350 351 mtk_vdec_debug(inst->ctx, "frame[%d] bs(%zu 0x%llx) y/c(0x%llx 0x%llx)", 352 inst->ctx->decoded_frame_cnt, 353 bs->size, (u64)bs->dma_addr, 354 y_fb_dma, c_fb_dma); 355 356 v4l2_m2m_buf_copy_metadata(&src_buf_info->m2m_buf.vb, 357 &dst_buf_info->m2m_buf.vb, true); 358 359 err = vdec_vp8_slice_get_decode_parameters(inst); 360 if (err) 361 goto error; 362 363 err = vpu_dec_start(vpu, &data, 1); 364 if (err) { 365 mtk_vdec_debug(inst->ctx, "vp8 dec start err!"); 366 goto error; 367 } 368 369 if (inst->vsi->dec.resolution_changed) { 370 mtk_vdec_debug(inst->ctx, "- resolution_changed -"); 371 *res_chg = true; 372 return 0; 373 } 374 375 /* wait decode done interrupt */ 376 timeout = mtk_vcodec_wait_for_done_ctx(inst->ctx, MTK_INST_IRQ_RECEIVED, 377 50, MTK_VDEC_CORE); 378 379 err = vpu_dec_end(vpu); 380 if (err || timeout) 381 mtk_vdec_debug(inst->ctx, "vp8 dec error timeout:%d err: %d pic_%d", 382 timeout, err, inst->ctx->decoded_frame_cnt); 383 384 mtk_vdec_debug(inst->ctx, "pic[%d] crc: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", 385 inst->ctx->decoded_frame_cnt, 386 inst->vsi->dec.crc[0], inst->vsi->dec.crc[1], 387 inst->vsi->dec.crc[2], inst->vsi->dec.crc[3], 388 inst->vsi->dec.crc[4], inst->vsi->dec.crc[5], 389 inst->vsi->dec.crc[6], inst->vsi->dec.crc[7]); 390 391 inst->ctx->decoded_frame_cnt++; 392error: 393 return err; 394} 395 396static int vdec_vp8_slice_get_param(void *h_vdec, enum vdec_get_param_type type, void *out) 397{ 398 struct vdec_vp8_slice_inst *inst = h_vdec; 399 400 switch (type) { 401 case GET_PARAM_PIC_INFO: 402 vdec_vp8_slice_get_pic_info(inst); 403 break; 404 case GET_PARAM_CROP_INFO: 405 mtk_vdec_debug(inst->ctx, "No need to get vp8 crop information."); 406 break; 407 case GET_PARAM_DPB_SIZE: 408 *((unsigned int *)out) = VP8_DPB_SIZE; 409 break; 410 default: 411 mtk_vdec_err(inst->ctx, "invalid get parameter type=%d", type); 412 return -EINVAL; 413 } 414 415 return 0; 416} 417 418static void vdec_vp8_slice_deinit(void *h_vdec) 419{ 420 struct vdec_vp8_slice_inst *inst = h_vdec; 421 422 vpu_dec_deinit(&inst->vpu); 423 vdec_vp8_slice_free_working_buf(inst); 424 kfree(inst); 425} 426 427const struct vdec_common_if vdec_vp8_slice_if = { 428 .init = vdec_vp8_slice_init, 429 .decode = vdec_vp8_slice_decode, 430 .get_param = vdec_vp8_slice_get_param, 431 .deinit = vdec_vp8_slice_deinit, 432}; 433