1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2016 MediaTek Inc. 4 * Author: PC Chen <pc.chen@mediatek.com> 5 * Tiffany Lin <tiffany.lin@mediatek.com> 6 */ 7 8 #include <media/v4l2-event.h> 9 #include <media/v4l2-mem2mem.h> 10 #include <media/videobuf2-dma-contig.h> 11 12 #include "mtk_vcodec_dec_drv.h" 13 #include "mtk_vcodec_dec.h" 14 #include "vdec_drv_if.h" 15 #include "mtk_vcodec_dec_pm.h" 16 17 #define DFT_CFG_WIDTH MTK_VDEC_MIN_W 18 #define DFT_CFG_HEIGHT MTK_VDEC_MIN_H 19 20 static const struct mtk_video_fmt * 21 mtk_vdec_find_format(struct v4l2_format *f, 22 const struct mtk_vcodec_dec_pdata *dec_pdata) 23 { 24 const struct mtk_video_fmt *fmt; 25 unsigned int k; 26 27 for (k = 0; k < *dec_pdata->num_formats; k++) { 28 fmt = &dec_pdata->vdec_formats[k]; 29 if (fmt->fourcc == f->fmt.pix_mp.pixelformat) 30 return fmt; 31 } 32 33 return NULL; 34 } 35 36 static bool mtk_vdec_get_cap_fmt(struct mtk_vcodec_dec_ctx *ctx, int format_index) 37 { 38 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 39 const struct mtk_video_fmt *fmt; 40 struct mtk_q_data *q_data; 41 int num_frame_count = 0, i; 42 bool ret = false; 43 44 fmt = &dec_pdata->vdec_formats[format_index]; 45 for (i = 0; i < *dec_pdata->num_formats; i++) { 46 if (dec_pdata->vdec_formats[i].type != MTK_FMT_FRAME) 47 continue; 48 49 num_frame_count++; 50 } 51 52 if (num_frame_count == 1 || (!ctx->is_10bit_bitstream && fmt->fourcc == V4L2_PIX_FMT_MM21)) 53 return true; 54 55 q_data = &ctx->q_data[MTK_Q_DATA_SRC]; 56 switch (q_data->fmt->fourcc) { 57 case V4L2_PIX_FMT_H264_SLICE: 58 if (ctx->is_10bit_bitstream && fmt->fourcc == V4L2_PIX_FMT_MT2110R) 59 ret = true; 60 break; 61 case V4L2_PIX_FMT_VP9_FRAME: 62 case V4L2_PIX_FMT_AV1_FRAME: 63 case V4L2_PIX_FMT_HEVC_SLICE: 64 if (ctx->is_10bit_bitstream && fmt->fourcc == V4L2_PIX_FMT_MT2110T) 65 ret = true; 66 break; 67 default: 68 break; 69 } 70 71 return ret; 72 } 73 74 static struct mtk_q_data *mtk_vdec_get_q_data(struct mtk_vcodec_dec_ctx *ctx, 75 enum v4l2_buf_type type) 76 { 77 if (V4L2_TYPE_IS_OUTPUT(type)) 78 return &ctx->q_data[MTK_Q_DATA_SRC]; 79 80 return &ctx->q_data[MTK_Q_DATA_DST]; 81 } 82 83 static int vidioc_try_decoder_cmd(struct file *file, void *priv, 84 struct v4l2_decoder_cmd *cmd) 85 { 86 return v4l2_m2m_ioctl_try_decoder_cmd(file, priv, cmd); 87 } 88 89 90 static int vidioc_decoder_cmd(struct file *file, void *priv, 91 struct v4l2_decoder_cmd *cmd) 92 { 93 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 94 struct vb2_queue *src_vq, *dst_vq; 95 int ret; 96 97 ret = vidioc_try_decoder_cmd(file, priv, cmd); 98 if (ret) 99 return ret; 100 101 mtk_v4l2_vdec_dbg(1, ctx, "decoder cmd=%u", cmd->cmd); 102 dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx, 103 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 104 switch (cmd->cmd) { 105 case V4L2_DEC_CMD_STOP: 106 src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx, 107 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 108 if (!vb2_is_streaming(src_vq)) { 109 mtk_v4l2_vdec_dbg(1, ctx, "Output stream is off. No need to flush."); 110 return 0; 111 } 112 if (!vb2_is_streaming(dst_vq)) { 113 mtk_v4l2_vdec_dbg(1, ctx, "Capture stream is off. No need to flush."); 114 return 0; 115 } 116 v4l2_m2m_buf_queue(ctx->m2m_ctx, &ctx->empty_flush_buf.vb); 117 v4l2_m2m_try_schedule(ctx->m2m_ctx); 118 break; 119 120 case V4L2_DEC_CMD_START: 121 vb2_clear_last_buffer_dequeued(dst_vq); 122 break; 123 124 default: 125 return -EINVAL; 126 } 127 128 return 0; 129 } 130 131 void mtk_vdec_unlock(struct mtk_vcodec_dec_ctx *ctx) 132 { 133 mutex_unlock(&ctx->dev->dec_mutex[ctx->hw_id]); 134 } 135 136 void mtk_vdec_lock(struct mtk_vcodec_dec_ctx *ctx) 137 { 138 mutex_lock(&ctx->dev->dec_mutex[ctx->hw_id]); 139 } 140 141 void mtk_vcodec_dec_release(struct mtk_vcodec_dec_ctx *ctx) 142 { 143 vdec_if_deinit(ctx); 144 ctx->state = MTK_STATE_FREE; 145 } 146 147 void mtk_vcodec_dec_set_default_params(struct mtk_vcodec_dec_ctx *ctx) 148 { 149 struct mtk_q_data *q_data; 150 151 ctx->m2m_ctx->q_lock = &ctx->dev->dev_mutex; 152 ctx->fh.m2m_ctx = ctx->m2m_ctx; 153 ctx->fh.ctrl_handler = &ctx->ctrl_hdl; 154 INIT_WORK(&ctx->decode_work, ctx->dev->vdec_pdata->worker); 155 ctx->colorspace = V4L2_COLORSPACE_REC709; 156 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 157 ctx->quantization = V4L2_QUANTIZATION_DEFAULT; 158 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT; 159 160 q_data = &ctx->q_data[MTK_Q_DATA_SRC]; 161 memset(q_data, 0, sizeof(struct mtk_q_data)); 162 q_data->visible_width = DFT_CFG_WIDTH; 163 q_data->visible_height = DFT_CFG_HEIGHT; 164 q_data->fmt = ctx->dev->vdec_pdata->default_out_fmt; 165 q_data->field = V4L2_FIELD_NONE; 166 167 q_data->sizeimage[0] = DFT_CFG_WIDTH * DFT_CFG_HEIGHT; 168 q_data->bytesperline[0] = 0; 169 170 q_data = &ctx->q_data[MTK_Q_DATA_DST]; 171 memset(q_data, 0, sizeof(struct mtk_q_data)); 172 q_data->visible_width = DFT_CFG_WIDTH; 173 q_data->visible_height = DFT_CFG_HEIGHT; 174 q_data->coded_width = DFT_CFG_WIDTH; 175 q_data->coded_height = DFT_CFG_HEIGHT; 176 q_data->fmt = ctx->dev->vdec_pdata->default_cap_fmt; 177 q_data->field = V4L2_FIELD_NONE; 178 179 q_data->sizeimage[0] = q_data->coded_width * q_data->coded_height; 180 q_data->bytesperline[0] = q_data->coded_width; 181 q_data->sizeimage[1] = q_data->sizeimage[0] / 2; 182 q_data->bytesperline[1] = q_data->coded_width; 183 } 184 185 static int vidioc_vdec_qbuf(struct file *file, void *priv, 186 struct v4l2_buffer *buf) 187 { 188 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 189 190 if (ctx->state == MTK_STATE_ABORT) { 191 mtk_v4l2_vdec_err(ctx, "[%d] Call on QBUF after unrecoverable error", ctx->id); 192 return -EIO; 193 } 194 195 return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf); 196 } 197 198 static int vidioc_vdec_dqbuf(struct file *file, void *priv, 199 struct v4l2_buffer *buf) 200 { 201 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 202 203 if (ctx->state == MTK_STATE_ABORT) { 204 mtk_v4l2_vdec_err(ctx, "[%d] Call on DQBUF after unrecoverable error", ctx->id); 205 return -EIO; 206 } 207 208 return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf); 209 } 210 211 static int mtk_vcodec_dec_get_chip_name(void *priv) 212 { 213 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 214 struct device *dev = &ctx->dev->plat_dev->dev; 215 216 if (of_device_is_compatible(dev->of_node, "mediatek,mt8173-vcodec-dec")) 217 return 8173; 218 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8183-vcodec-dec")) 219 return 8183; 220 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8192-vcodec-dec")) 221 return 8192; 222 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8195-vcodec-dec")) 223 return 8195; 224 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8186-vcodec-dec")) 225 return 8186; 226 else if (of_device_is_compatible(dev->of_node, "mediatek,mt8188-vcodec-dec")) 227 return 8188; 228 else 229 return 8173; 230 } 231 232 static int vidioc_vdec_querycap(struct file *file, void *priv, 233 struct v4l2_capability *cap) 234 { 235 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 236 struct device *dev = &ctx->dev->plat_dev->dev; 237 int platform_name = mtk_vcodec_dec_get_chip_name(priv); 238 239 strscpy(cap->driver, dev->driver->name, sizeof(cap->driver)); 240 snprintf(cap->card, sizeof(cap->card), "MT%d video decoder", platform_name); 241 242 return 0; 243 } 244 245 static int vidioc_vdec_subscribe_evt(struct v4l2_fh *fh, 246 const struct v4l2_event_subscription *sub) 247 { 248 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(fh); 249 250 if (ctx->dev->vdec_pdata->uses_stateless_api) 251 return v4l2_ctrl_subscribe_event(fh, sub); 252 253 switch (sub->type) { 254 case V4L2_EVENT_EOS: 255 return v4l2_event_subscribe(fh, sub, 2, NULL); 256 case V4L2_EVENT_SOURCE_CHANGE: 257 return v4l2_src_change_event_subscribe(fh, sub); 258 default: 259 return v4l2_ctrl_subscribe_event(fh, sub); 260 } 261 } 262 263 static int vidioc_try_fmt(struct mtk_vcodec_dec_ctx *ctx, struct v4l2_format *f, 264 const struct mtk_video_fmt *fmt) 265 { 266 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp; 267 const struct v4l2_frmsize_stepwise *frmsize; 268 269 pix_fmt_mp->field = V4L2_FIELD_NONE; 270 271 /* Always apply frame size constraints from the coded side */ 272 if (V4L2_TYPE_IS_OUTPUT(f->type)) 273 frmsize = &fmt->frmsize; 274 else 275 frmsize = &ctx->q_data[MTK_Q_DATA_SRC].fmt->frmsize; 276 277 pix_fmt_mp->width = clamp(pix_fmt_mp->width, MTK_VDEC_MIN_W, frmsize->max_width); 278 pix_fmt_mp->height = clamp(pix_fmt_mp->height, MTK_VDEC_MIN_H, frmsize->max_height); 279 280 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 281 pix_fmt_mp->num_planes = 1; 282 pix_fmt_mp->plane_fmt[0].bytesperline = 0; 283 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 284 int tmp_w, tmp_h; 285 286 /* 287 * Find next closer width align 64, heign align 64, size align 288 * 64 rectangle 289 * Note: This only get default value, the real HW needed value 290 * only available when ctx in MTK_STATE_HEADER state 291 */ 292 tmp_w = pix_fmt_mp->width; 293 tmp_h = pix_fmt_mp->height; 294 v4l_bound_align_image(&pix_fmt_mp->width, MTK_VDEC_MIN_W, frmsize->max_width, 6, 295 &pix_fmt_mp->height, MTK_VDEC_MIN_H, frmsize->max_height, 6, 296 9); 297 298 if (pix_fmt_mp->width < tmp_w && 299 (pix_fmt_mp->width + 64) <= frmsize->max_width) 300 pix_fmt_mp->width += 64; 301 if (pix_fmt_mp->height < tmp_h && 302 (pix_fmt_mp->height + 64) <= frmsize->max_height) 303 pix_fmt_mp->height += 64; 304 305 mtk_v4l2_vdec_dbg(0, ctx, 306 "before resize wxh=%dx%d, after resize wxh=%dx%d, sizeimage=%d", 307 tmp_w, tmp_h, pix_fmt_mp->width, pix_fmt_mp->height, 308 pix_fmt_mp->width * pix_fmt_mp->height); 309 310 pix_fmt_mp->num_planes = fmt->num_planes; 311 pix_fmt_mp->plane_fmt[0].sizeimage = 312 pix_fmt_mp->width * pix_fmt_mp->height; 313 pix_fmt_mp->plane_fmt[0].bytesperline = pix_fmt_mp->width; 314 315 if (pix_fmt_mp->num_planes == 2) { 316 pix_fmt_mp->plane_fmt[1].sizeimage = 317 (pix_fmt_mp->width * pix_fmt_mp->height) / 2; 318 pix_fmt_mp->plane_fmt[1].bytesperline = 319 pix_fmt_mp->width; 320 } 321 } 322 323 pix_fmt_mp->flags = 0; 324 return 0; 325 } 326 327 static int vidioc_try_fmt_vid_cap_mplane(struct file *file, void *priv, 328 struct v4l2_format *f) 329 { 330 const struct mtk_video_fmt *fmt; 331 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 332 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 333 334 fmt = mtk_vdec_find_format(f, dec_pdata); 335 if (!fmt) { 336 f->fmt.pix.pixelformat = 337 ctx->q_data[MTK_Q_DATA_DST].fmt->fourcc; 338 fmt = mtk_vdec_find_format(f, dec_pdata); 339 } 340 341 return vidioc_try_fmt(ctx, f, fmt); 342 } 343 344 static int vidioc_try_fmt_vid_out_mplane(struct file *file, void *priv, 345 struct v4l2_format *f) 346 { 347 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp; 348 const struct mtk_video_fmt *fmt; 349 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 350 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 351 352 fmt = mtk_vdec_find_format(f, dec_pdata); 353 if (!fmt) { 354 f->fmt.pix.pixelformat = 355 ctx->q_data[MTK_Q_DATA_SRC].fmt->fourcc; 356 fmt = mtk_vdec_find_format(f, dec_pdata); 357 } 358 359 if (pix_fmt_mp->plane_fmt[0].sizeimage == 0) { 360 mtk_v4l2_vdec_err(ctx, "sizeimage of output format must be given"); 361 return -EINVAL; 362 } 363 364 return vidioc_try_fmt(ctx, f, fmt); 365 } 366 367 static int vidioc_vdec_g_selection(struct file *file, void *priv, 368 struct v4l2_selection *s) 369 { 370 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 371 struct mtk_q_data *q_data; 372 373 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 374 return -EINVAL; 375 376 q_data = &ctx->q_data[MTK_Q_DATA_DST]; 377 378 switch (s->target) { 379 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 380 s->r.left = 0; 381 s->r.top = 0; 382 s->r.width = ctx->picinfo.pic_w; 383 s->r.height = ctx->picinfo.pic_h; 384 break; 385 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 386 s->r.left = 0; 387 s->r.top = 0; 388 s->r.width = ctx->picinfo.buf_w; 389 s->r.height = ctx->picinfo.buf_h; 390 break; 391 case V4L2_SEL_TGT_COMPOSE: 392 if (vdec_if_get_param(ctx, GET_PARAM_CROP_INFO, &(s->r))) { 393 /* set to default value if header info not ready yet*/ 394 s->r.left = 0; 395 s->r.top = 0; 396 s->r.width = q_data->visible_width; 397 s->r.height = q_data->visible_height; 398 } 399 break; 400 default: 401 return -EINVAL; 402 } 403 404 if (ctx->state < MTK_STATE_HEADER) { 405 /* set to default value if header info not ready yet*/ 406 s->r.left = 0; 407 s->r.top = 0; 408 s->r.width = q_data->visible_width; 409 s->r.height = q_data->visible_height; 410 return 0; 411 } 412 413 return 0; 414 } 415 416 static int vidioc_vdec_s_selection(struct file *file, void *priv, 417 struct v4l2_selection *s) 418 { 419 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 420 421 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 422 return -EINVAL; 423 424 switch (s->target) { 425 case V4L2_SEL_TGT_COMPOSE: 426 s->r.left = 0; 427 s->r.top = 0; 428 s->r.width = ctx->picinfo.pic_w; 429 s->r.height = ctx->picinfo.pic_h; 430 break; 431 default: 432 return -EINVAL; 433 } 434 435 return 0; 436 } 437 438 static int vidioc_vdec_s_fmt(struct file *file, void *priv, 439 struct v4l2_format *f) 440 { 441 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 442 struct v4l2_pix_format_mplane *pix_mp; 443 struct mtk_q_data *q_data; 444 int ret = 0; 445 const struct mtk_video_fmt *fmt; 446 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 447 448 mtk_v4l2_vdec_dbg(3, ctx, "[%d]", ctx->id); 449 450 q_data = mtk_vdec_get_q_data(ctx, f->type); 451 if (!q_data) 452 return -EINVAL; 453 454 pix_mp = &f->fmt.pix_mp; 455 /* 456 * Setting OUTPUT format after OUTPUT buffers are allocated is invalid 457 * if using the stateful API. 458 */ 459 if (!dec_pdata->uses_stateless_api && 460 f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE && 461 vb2_is_busy(&ctx->m2m_ctx->out_q_ctx.q)) { 462 mtk_v4l2_vdec_err(ctx, "out_q_ctx buffers already requested"); 463 ret = -EBUSY; 464 } 465 466 /* 467 * Setting CAPTURE format after CAPTURE buffers are allocated is 468 * invalid. 469 */ 470 if ((f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) && 471 vb2_is_busy(&ctx->m2m_ctx->cap_q_ctx.q)) { 472 mtk_v4l2_vdec_err(ctx, "cap_q_ctx buffers already requested"); 473 ret = -EBUSY; 474 } 475 476 fmt = mtk_vdec_find_format(f, dec_pdata); 477 if (fmt == NULL) { 478 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 479 f->fmt.pix.pixelformat = 480 dec_pdata->default_out_fmt->fourcc; 481 fmt = mtk_vdec_find_format(f, dec_pdata); 482 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 483 f->fmt.pix.pixelformat = 484 dec_pdata->default_cap_fmt->fourcc; 485 fmt = mtk_vdec_find_format(f, dec_pdata); 486 } 487 } 488 if (fmt == NULL) 489 return -EINVAL; 490 491 q_data->fmt = fmt; 492 vidioc_try_fmt(ctx, f, q_data->fmt); 493 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 494 q_data->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage; 495 q_data->coded_width = pix_mp->width; 496 q_data->coded_height = pix_mp->height; 497 498 ctx->colorspace = pix_mp->colorspace; 499 ctx->ycbcr_enc = pix_mp->ycbcr_enc; 500 ctx->quantization = pix_mp->quantization; 501 ctx->xfer_func = pix_mp->xfer_func; 502 503 ctx->current_codec = fmt->fourcc; 504 if (ctx->state == MTK_STATE_FREE) { 505 ret = vdec_if_init(ctx, q_data->fmt->fourcc); 506 if (ret) { 507 mtk_v4l2_vdec_err(ctx, "[%d]: vdec_if_init() fail ret=%d", 508 ctx->id, ret); 509 return -EINVAL; 510 } 511 ctx->state = MTK_STATE_INIT; 512 } 513 } else { 514 ctx->capture_fourcc = fmt->fourcc; 515 } 516 517 /* 518 * If using the stateless API, S_FMT should have the effect of setting 519 * the CAPTURE queue resolution no matter which queue it was called on. 520 */ 521 if (dec_pdata->uses_stateless_api) { 522 ctx->picinfo.pic_w = pix_mp->width; 523 ctx->picinfo.pic_h = pix_mp->height; 524 525 /* 526 * If get pic info fail, need to use the default pic info params, or 527 * v4l2-compliance will fail 528 */ 529 ret = vdec_if_get_param(ctx, GET_PARAM_PIC_INFO, &ctx->picinfo); 530 if (ret) { 531 mtk_v4l2_vdec_err(ctx, "[%d]Error!! Get GET_PARAM_PICTURE_INFO Fail", 532 ctx->id); 533 } 534 535 ctx->last_decoded_picinfo = ctx->picinfo; 536 537 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 1) { 538 ctx->q_data[MTK_Q_DATA_DST].sizeimage[0] = 539 ctx->picinfo.fb_sz[0] + 540 ctx->picinfo.fb_sz[1]; 541 ctx->q_data[MTK_Q_DATA_DST].bytesperline[0] = 542 ctx->picinfo.buf_w; 543 } else { 544 ctx->q_data[MTK_Q_DATA_DST].sizeimage[0] = 545 ctx->picinfo.fb_sz[0]; 546 ctx->q_data[MTK_Q_DATA_DST].bytesperline[0] = 547 ctx->picinfo.buf_w; 548 ctx->q_data[MTK_Q_DATA_DST].sizeimage[1] = 549 ctx->picinfo.fb_sz[1]; 550 ctx->q_data[MTK_Q_DATA_DST].bytesperline[1] = 551 ctx->picinfo.buf_w; 552 } 553 554 ctx->q_data[MTK_Q_DATA_DST].coded_width = ctx->picinfo.buf_w; 555 ctx->q_data[MTK_Q_DATA_DST].coded_height = ctx->picinfo.buf_h; 556 mtk_v4l2_vdec_dbg(2, ctx, 557 "[%d] init() plane:%d wxh=%dx%d pic wxh=%dx%d sz=0x%x_0x%x", 558 ctx->id, pix_mp->num_planes, 559 ctx->picinfo.buf_w, ctx->picinfo.buf_h, 560 ctx->picinfo.pic_w, ctx->picinfo.pic_h, 561 ctx->q_data[MTK_Q_DATA_DST].sizeimage[0], 562 ctx->q_data[MTK_Q_DATA_DST].sizeimage[1]); 563 } 564 return 0; 565 } 566 567 static int vidioc_enum_framesizes(struct file *file, void *priv, 568 struct v4l2_frmsizeenum *fsize) 569 { 570 int i = 0; 571 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 572 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 573 574 if (fsize->index != 0) 575 return -EINVAL; 576 577 for (i = 0; i < *dec_pdata->num_formats; i++) { 578 if (fsize->pixel_format != dec_pdata->vdec_formats[i].fourcc) 579 continue; 580 581 /* Only coded formats have frame sizes set */ 582 if (!dec_pdata->vdec_formats[i].frmsize.max_width) 583 return -ENOTTY; 584 585 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 586 fsize->stepwise = dec_pdata->vdec_formats[i].frmsize; 587 588 mtk_v4l2_vdec_dbg(1, ctx, "%x, %d %d %d %d %d %d", 589 ctx->dev->dec_capability, fsize->stepwise.min_width, 590 fsize->stepwise.max_width, fsize->stepwise.step_width, 591 fsize->stepwise.min_height, fsize->stepwise.max_height, 592 fsize->stepwise.step_height); 593 594 return 0; 595 } 596 597 return -EINVAL; 598 } 599 600 static int vidioc_enum_fmt(struct v4l2_fmtdesc *f, void *priv, 601 bool output_queue) 602 { 603 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 604 const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata; 605 const struct mtk_video_fmt *fmt; 606 int i, j = 0; 607 608 for (i = 0; i < *dec_pdata->num_formats; i++) { 609 if (output_queue && 610 dec_pdata->vdec_formats[i].type != MTK_FMT_DEC) 611 continue; 612 if (!output_queue && 613 dec_pdata->vdec_formats[i].type != MTK_FMT_FRAME) 614 continue; 615 616 if (!output_queue && !mtk_vdec_get_cap_fmt(ctx, i)) 617 continue; 618 619 if (j == f->index) 620 break; 621 ++j; 622 } 623 624 if (i == *dec_pdata->num_formats) 625 return -EINVAL; 626 627 fmt = &dec_pdata->vdec_formats[i]; 628 f->pixelformat = fmt->fourcc; 629 f->flags = fmt->flags; 630 631 return 0; 632 } 633 634 static int vidioc_vdec_enum_fmt_vid_cap(struct file *file, void *priv, 635 struct v4l2_fmtdesc *f) 636 { 637 return vidioc_enum_fmt(f, priv, false); 638 } 639 640 static int vidioc_vdec_enum_fmt_vid_out(struct file *file, void *priv, 641 struct v4l2_fmtdesc *f) 642 { 643 return vidioc_enum_fmt(f, priv, true); 644 } 645 646 static int vidioc_vdec_g_fmt(struct file *file, void *priv, 647 struct v4l2_format *f) 648 { 649 struct mtk_vcodec_dec_ctx *ctx = fh_to_dec_ctx(priv); 650 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; 651 struct vb2_queue *vq; 652 struct mtk_q_data *q_data; 653 654 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type); 655 if (!vq) { 656 mtk_v4l2_vdec_err(ctx, "no vb2 queue for type=%d", f->type); 657 return -EINVAL; 658 } 659 660 q_data = mtk_vdec_get_q_data(ctx, f->type); 661 662 pix_mp->field = V4L2_FIELD_NONE; 663 pix_mp->colorspace = ctx->colorspace; 664 pix_mp->ycbcr_enc = ctx->ycbcr_enc; 665 pix_mp->quantization = ctx->quantization; 666 pix_mp->xfer_func = ctx->xfer_func; 667 668 if ((f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) && 669 (ctx->state >= MTK_STATE_HEADER)) { 670 /* Until STREAMOFF is called on the CAPTURE queue 671 * (acknowledging the event), the driver operates as if 672 * the resolution hasn't changed yet. 673 * So we just return picinfo yet, and update picinfo in 674 * stop_streaming hook function 675 */ 676 q_data->sizeimage[0] = ctx->picinfo.fb_sz[0]; 677 q_data->sizeimage[1] = ctx->picinfo.fb_sz[1]; 678 q_data->bytesperline[0] = ctx->last_decoded_picinfo.buf_w; 679 q_data->bytesperline[1] = ctx->last_decoded_picinfo.buf_w; 680 q_data->coded_width = ctx->picinfo.buf_w; 681 q_data->coded_height = ctx->picinfo.buf_h; 682 ctx->last_decoded_picinfo.cap_fourcc = q_data->fmt->fourcc; 683 684 /* 685 * Width and height are set to the dimensions 686 * of the movie, the buffer is bigger and 687 * further processing stages should crop to this 688 * rectangle. 689 */ 690 pix_mp->width = q_data->coded_width; 691 pix_mp->height = q_data->coded_height; 692 693 /* 694 * Set pixelformat to the format in which mt vcodec 695 * outputs the decoded frame 696 */ 697 pix_mp->num_planes = q_data->fmt->num_planes; 698 pix_mp->pixelformat = q_data->fmt->fourcc; 699 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0]; 700 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0]; 701 pix_mp->plane_fmt[1].bytesperline = q_data->bytesperline[1]; 702 pix_mp->plane_fmt[1].sizeimage = q_data->sizeimage[1]; 703 704 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 705 /* 706 * This is run on OUTPUT 707 * The buffer contains compressed image 708 * so width and height have no meaning. 709 * Assign value here to pass v4l2-compliance test 710 */ 711 pix_mp->width = q_data->visible_width; 712 pix_mp->height = q_data->visible_height; 713 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0]; 714 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0]; 715 pix_mp->pixelformat = q_data->fmt->fourcc; 716 pix_mp->num_planes = q_data->fmt->num_planes; 717 } else { 718 pix_mp->width = q_data->coded_width; 719 pix_mp->height = q_data->coded_height; 720 pix_mp->num_planes = q_data->fmt->num_planes; 721 pix_mp->pixelformat = q_data->fmt->fourcc; 722 pix_mp->plane_fmt[0].bytesperline = q_data->bytesperline[0]; 723 pix_mp->plane_fmt[0].sizeimage = q_data->sizeimage[0]; 724 pix_mp->plane_fmt[1].bytesperline = q_data->bytesperline[1]; 725 pix_mp->plane_fmt[1].sizeimage = q_data->sizeimage[1]; 726 727 mtk_v4l2_vdec_dbg(1, ctx, "[%d] type=%d state=%d Format information not ready!", 728 ctx->id, f->type, ctx->state); 729 } 730 731 return 0; 732 } 733 734 int vb2ops_vdec_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, 735 unsigned int *nplanes, unsigned int sizes[], 736 struct device *alloc_devs[]) 737 { 738 struct mtk_vcodec_dec_ctx *ctx = vb2_get_drv_priv(vq); 739 struct mtk_q_data *q_data; 740 unsigned int i; 741 742 q_data = mtk_vdec_get_q_data(ctx, vq->type); 743 744 if (q_data == NULL) { 745 mtk_v4l2_vdec_err(ctx, "vq->type=%d err\n", vq->type); 746 return -EINVAL; 747 } 748 749 if (*nplanes) { 750 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 751 if (*nplanes != q_data->fmt->num_planes) 752 return -EINVAL; 753 } else { 754 if (*nplanes != 1) 755 return -EINVAL; 756 } 757 for (i = 0; i < *nplanes; i++) { 758 if (sizes[i] < q_data->sizeimage[i]) 759 return -EINVAL; 760 } 761 } else { 762 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 763 *nplanes = q_data->fmt->num_planes; 764 else 765 *nplanes = 1; 766 767 for (i = 0; i < *nplanes; i++) 768 sizes[i] = q_data->sizeimage[i]; 769 } 770 771 mtk_v4l2_vdec_dbg(1, ctx, 772 "[%d]\t type = %d, get %d plane(s), %d buffer(s) of size 0x%x 0x%x ", 773 ctx->id, vq->type, *nplanes, *nbuffers, sizes[0], sizes[1]); 774 775 return 0; 776 } 777 778 int vb2ops_vdec_buf_prepare(struct vb2_buffer *vb) 779 { 780 struct mtk_vcodec_dec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 781 struct mtk_q_data *q_data; 782 int i; 783 784 mtk_v4l2_vdec_dbg(3, ctx, "[%d] (%d) id=%d", 785 ctx->id, vb->vb2_queue->type, vb->index); 786 787 q_data = mtk_vdec_get_q_data(ctx, vb->vb2_queue->type); 788 789 for (i = 0; i < q_data->fmt->num_planes; i++) { 790 if (vb2_plane_size(vb, i) < q_data->sizeimage[i]) { 791 mtk_v4l2_vdec_err(ctx, "data will not fit into plane %d (%lu < %d)", 792 i, vb2_plane_size(vb, i), q_data->sizeimage[i]); 793 return -EINVAL; 794 } 795 if (!V4L2_TYPE_IS_OUTPUT(vb->type)) 796 vb2_set_plane_payload(vb, i, q_data->sizeimage[i]); 797 } 798 799 return 0; 800 } 801 802 void vb2ops_vdec_buf_finish(struct vb2_buffer *vb) 803 { 804 struct mtk_vcodec_dec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 805 struct vb2_v4l2_buffer *vb2_v4l2; 806 struct mtk_video_dec_buf *buf; 807 bool buf_error; 808 809 vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf); 810 buf = container_of(vb2_v4l2, struct mtk_video_dec_buf, m2m_buf.vb); 811 mutex_lock(&ctx->lock); 812 if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 813 buf->queued_in_v4l2 = false; 814 buf->queued_in_vb2 = false; 815 } 816 buf_error = buf->error; 817 mutex_unlock(&ctx->lock); 818 819 if (buf_error) { 820 mtk_v4l2_vdec_err(ctx, "Unrecoverable error on buffer."); 821 ctx->state = MTK_STATE_ABORT; 822 } 823 } 824 825 int vb2ops_vdec_buf_init(struct vb2_buffer *vb) 826 { 827 struct vb2_v4l2_buffer *vb2_v4l2 = container_of(vb, 828 struct vb2_v4l2_buffer, vb2_buf); 829 struct mtk_video_dec_buf *buf = container_of(vb2_v4l2, 830 struct mtk_video_dec_buf, m2m_buf.vb); 831 832 if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { 833 buf->used = false; 834 buf->queued_in_v4l2 = false; 835 } 836 837 return 0; 838 } 839 840 int vb2ops_vdec_start_streaming(struct vb2_queue *q, unsigned int count) 841 { 842 struct mtk_vcodec_dec_ctx *ctx = vb2_get_drv_priv(q); 843 844 if (ctx->state == MTK_STATE_FLUSH) 845 ctx->state = MTK_STATE_HEADER; 846 847 return 0; 848 } 849 850 void vb2ops_vdec_stop_streaming(struct vb2_queue *q) 851 { 852 struct vb2_v4l2_buffer *src_buf = NULL, *dst_buf = NULL; 853 struct mtk_vcodec_dec_ctx *ctx = vb2_get_drv_priv(q); 854 int ret; 855 856 mtk_v4l2_vdec_dbg(3, ctx, "[%d] (%d) state=(%x) ctx->decoded_frame_cnt=%d", 857 ctx->id, q->type, ctx->state, ctx->decoded_frame_cnt); 858 859 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 860 while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) { 861 if (src_buf != &ctx->empty_flush_buf.vb) { 862 struct media_request *req = 863 src_buf->vb2_buf.req_obj.req; 864 v4l2_m2m_buf_done(src_buf, 865 VB2_BUF_STATE_ERROR); 866 if (req) 867 v4l2_ctrl_request_complete(req, &ctx->ctrl_hdl); 868 } 869 } 870 return; 871 } 872 873 if (ctx->state >= MTK_STATE_HEADER) { 874 875 /* Until STREAMOFF is called on the CAPTURE queue 876 * (acknowledging the event), the driver operates 877 * as if the resolution hasn't changed yet, i.e. 878 * VIDIOC_G_FMT< etc. return previous resolution. 879 * So we update picinfo here 880 */ 881 ctx->picinfo = ctx->last_decoded_picinfo; 882 883 mtk_v4l2_vdec_dbg(2, ctx, 884 "[%d]-> new(%d,%d), old(%d,%d), real(%d,%d)", 885 ctx->id, ctx->last_decoded_picinfo.pic_w, 886 ctx->last_decoded_picinfo.pic_h, 887 ctx->picinfo.pic_w, ctx->picinfo.pic_h, 888 ctx->last_decoded_picinfo.buf_w, 889 ctx->last_decoded_picinfo.buf_h); 890 891 ret = ctx->dev->vdec_pdata->flush_decoder(ctx); 892 if (ret) 893 mtk_v4l2_vdec_err(ctx, "DecodeFinal failed, ret=%d", ret); 894 } 895 ctx->state = MTK_STATE_FLUSH; 896 897 while ((dst_buf = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx))) { 898 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0); 899 if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2) 900 vb2_set_plane_payload(&dst_buf->vb2_buf, 1, 0); 901 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR); 902 } 903 904 } 905 906 static void m2mops_vdec_device_run(void *priv) 907 { 908 struct mtk_vcodec_dec_ctx *ctx = priv; 909 struct mtk_vcodec_dec_dev *dev = ctx->dev; 910 911 queue_work(dev->decode_workqueue, &ctx->decode_work); 912 } 913 914 static int m2mops_vdec_job_ready(void *m2m_priv) 915 { 916 struct mtk_vcodec_dec_ctx *ctx = m2m_priv; 917 918 mtk_v4l2_vdec_dbg(3, ctx, "[%d]", ctx->id); 919 920 if (ctx->state == MTK_STATE_ABORT) 921 return 0; 922 923 if ((ctx->last_decoded_picinfo.pic_w != ctx->picinfo.pic_w) || 924 (ctx->last_decoded_picinfo.pic_h != ctx->picinfo.pic_h)) 925 return 0; 926 927 if (ctx->state != MTK_STATE_HEADER) 928 return 0; 929 930 return 1; 931 } 932 933 static void m2mops_vdec_job_abort(void *priv) 934 { 935 struct mtk_vcodec_dec_ctx *ctx = priv; 936 937 ctx->state = MTK_STATE_ABORT; 938 } 939 940 const struct v4l2_m2m_ops mtk_vdec_m2m_ops = { 941 .device_run = m2mops_vdec_device_run, 942 .job_ready = m2mops_vdec_job_ready, 943 .job_abort = m2mops_vdec_job_abort, 944 }; 945 946 const struct v4l2_ioctl_ops mtk_vdec_ioctl_ops = { 947 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 948 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 949 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 950 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 951 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 952 953 .vidioc_qbuf = vidioc_vdec_qbuf, 954 .vidioc_dqbuf = vidioc_vdec_dqbuf, 955 956 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane, 957 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane, 958 959 .vidioc_s_fmt_vid_cap_mplane = vidioc_vdec_s_fmt, 960 .vidioc_s_fmt_vid_out_mplane = vidioc_vdec_s_fmt, 961 .vidioc_g_fmt_vid_cap_mplane = vidioc_vdec_g_fmt, 962 .vidioc_g_fmt_vid_out_mplane = vidioc_vdec_g_fmt, 963 964 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 965 966 .vidioc_enum_fmt_vid_cap = vidioc_vdec_enum_fmt_vid_cap, 967 .vidioc_enum_fmt_vid_out = vidioc_vdec_enum_fmt_vid_out, 968 .vidioc_enum_framesizes = vidioc_enum_framesizes, 969 970 .vidioc_querycap = vidioc_vdec_querycap, 971 .vidioc_subscribe_event = vidioc_vdec_subscribe_evt, 972 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 973 .vidioc_g_selection = vidioc_vdec_g_selection, 974 .vidioc_s_selection = vidioc_vdec_s_selection, 975 976 .vidioc_decoder_cmd = vidioc_decoder_cmd, 977 .vidioc_try_decoder_cmd = vidioc_try_decoder_cmd, 978 }; 979 980 int mtk_vcodec_dec_queue_init(void *priv, struct vb2_queue *src_vq, 981 struct vb2_queue *dst_vq) 982 { 983 struct mtk_vcodec_dec_ctx *ctx = priv; 984 int ret = 0; 985 986 mtk_v4l2_vdec_dbg(3, ctx, "[%d]", ctx->id); 987 988 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 989 src_vq->io_modes = VB2_DMABUF | VB2_MMAP; 990 src_vq->drv_priv = ctx; 991 src_vq->buf_struct_size = sizeof(struct mtk_video_dec_buf); 992 src_vq->ops = ctx->dev->vdec_pdata->vdec_vb2_ops; 993 src_vq->mem_ops = &vb2_dma_contig_memops; 994 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 995 src_vq->lock = &ctx->dev->dev_mutex; 996 src_vq->dev = &ctx->dev->plat_dev->dev; 997 src_vq->allow_cache_hints = 1; 998 999 ret = vb2_queue_init(src_vq); 1000 if (ret) { 1001 mtk_v4l2_vdec_err(ctx, "Failed to initialize videobuf2 queue(output)"); 1002 return ret; 1003 } 1004 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1005 dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; 1006 dst_vq->drv_priv = ctx; 1007 dst_vq->buf_struct_size = sizeof(struct mtk_video_dec_buf); 1008 dst_vq->ops = ctx->dev->vdec_pdata->vdec_vb2_ops; 1009 dst_vq->mem_ops = &vb2_dma_contig_memops; 1010 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1011 dst_vq->lock = &ctx->dev->dev_mutex; 1012 dst_vq->dev = &ctx->dev->plat_dev->dev; 1013 dst_vq->allow_cache_hints = 1; 1014 1015 ret = vb2_queue_init(dst_vq); 1016 if (ret) 1017 mtk_v4l2_vdec_err(ctx, "Failed to initialize videobuf2 queue(capture)"); 1018 1019 return ret; 1020 } 1021