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 32struct 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 44struct 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 69static 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 192static 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 215static 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 220static 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 263static 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 285static 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 311static 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 326static 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 335static 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; 359exit: 360 vpu_inst_unlock(inst); 361 return ret; 362} 363 364static 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 395static 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 428static 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 501static 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 529exit: 530 vpu_inst_unlock(inst); 531 return ret; 532} 533 534static 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 560static 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 587static 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 606static 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 622static 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 647static 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 663static 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 689static 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 702static 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 710static 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 } 760exit: 761 vpu_inst_unlock(inst); 762 763 return ret; 764} 765 766static 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 781static 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 834static 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 857static 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 894static 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 914static 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 924static 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 935static 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 946static 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 953static 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 972static 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 984static 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 996static 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 1018static 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 1038static 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 1094static 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 1128static 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 1138static 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 1149static 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 1171static 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 1213static 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 1234static 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 1265static 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 1303exit: 1304 vpu_inst_unlock(inst); 1305} 1306 1307static 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 1325static 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 1348static 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 1390static 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 1408static 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 1420static 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 1458static 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 1475static 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 1482static 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 1495static void vdec_init_params(struct vdec_t *vdec) 1496{ 1497 vdec->params.frame_count = 0; 1498 vdec->params.end_flag = 0; 1499} 1500 1501static 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; 1554error: 1555 vpu_free_dma(&vdec->udata); 1556 vpu_free_dma(&inst->stream_buffer); 1557 return ret; 1558} 1559 1560static 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 1588static 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 vdec_abort(inst); 1599 } else { 1600 if (inst->state != VPU_CODEC_STATE_DYAMIC_RESOLUTION_CHANGE) { 1601 if (vb2_is_streaming(v4l2_m2m_get_src_vq(inst->fh.m2m_ctx))) 1602 vdec_abort(inst); 1603 vdec->eos_received = 0; 1604 } 1605 vdec_clear_slots(inst); 1606 } 1607 1608 return 0; 1609} 1610 1611static int vdec_get_debug_info(struct vpu_inst *inst, char *str, u32 size, u32 i) 1612{ 1613 struct vdec_t *vdec = inst->priv; 1614 int num = -1; 1615 1616 switch (i) { 1617 case 0: 1618 num = scnprintf(str, size, 1619 "req_frame_count = %d\ninterlaced = %d\n", 1620 vdec->req_frame_count, 1621 vdec->codec_info.progressive ? 0 : 1); 1622 break; 1623 case 1: 1624 num = scnprintf(str, size, 1625 "mbi: size = 0x%x request = %d, alloc = %d, response = %d\n", 1626 vdec->mbi.size, 1627 vdec->mbi.req_count, 1628 vdec->mbi.count, 1629 vdec->mbi.index); 1630 break; 1631 case 2: 1632 num = scnprintf(str, size, 1633 "dcp: size = 0x%x request = %d, alloc = %d, response = %d\n", 1634 vdec->dcp.size, 1635 vdec->dcp.req_count, 1636 vdec->dcp.count, 1637 vdec->dcp.index); 1638 break; 1639 case 3: 1640 num = scnprintf(str, size, "input_frame_count = %d\n", vdec->params.frame_count); 1641 break; 1642 case 4: 1643 num = scnprintf(str, size, "decoded_frame_count = %d\n", vdec->decoded_frame_count); 1644 break; 1645 case 5: 1646 num = scnprintf(str, size, "display_frame_count = %d\n", vdec->display_frame_count); 1647 break; 1648 case 6: 1649 num = scnprintf(str, size, "sequence = %d\n", vdec->sequence); 1650 break; 1651 case 7: 1652 num = scnprintf(str, size, "drain = %d, eos = %d, source_change = %d\n", 1653 vdec->drain, vdec->eos_received, vdec->source_change); 1654 break; 1655 case 8: 1656 num = scnprintf(str, size, "fps = %d/%d\n", 1657 vdec->codec_info.frame_rate.numerator, 1658 vdec->codec_info.frame_rate.denominator); 1659 break; 1660 case 9: 1661 num = scnprintf(str, size, "colorspace: %d, %d, %d, %d (%d)\n", 1662 vdec->codec_info.color_primaries, 1663 vdec->codec_info.transfer_chars, 1664 vdec->codec_info.matrix_coeffs, 1665 vdec->codec_info.full_range, 1666 vdec->codec_info.vui_present); 1667 break; 1668 default: 1669 break; 1670 } 1671 1672 return num; 1673} 1674 1675static struct vpu_inst_ops vdec_inst_ops = { 1676 .ctrl_init = vdec_ctrl_init, 1677 .check_ready = vdec_check_ready, 1678 .buf_done = vdec_buf_done, 1679 .get_one_frame = vdec_frame_decoded, 1680 .stop_done = vdec_stop_done, 1681 .event_notify = vdec_event_notify, 1682 .release = vdec_release, 1683 .cleanup = vdec_cleanup, 1684 .start = vdec_start_session, 1685 .stop = vdec_stop_session, 1686 .process_output = vdec_process_output, 1687 .process_capture = vdec_process_capture, 1688 .on_queue_empty = vdec_on_queue_empty, 1689 .get_debug_info = vdec_get_debug_info, 1690 .wait_prepare = vpu_inst_unlock, 1691 .wait_finish = vpu_inst_lock, 1692}; 1693 1694static void vdec_init(struct file *file) 1695{ 1696 struct vpu_inst *inst = to_inst(file); 1697 struct v4l2_format f; 1698 1699 memset(&f, 0, sizeof(f)); 1700 f.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1701 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264; 1702 f.fmt.pix_mp.width = 1280; 1703 f.fmt.pix_mp.height = 720; 1704 f.fmt.pix_mp.field = V4L2_FIELD_NONE; 1705 vdec_s_fmt(file, &inst->fh, &f); 1706 1707 memset(&f, 0, sizeof(f)); 1708 f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1709 f.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M_8L128; 1710 f.fmt.pix_mp.width = 1280; 1711 f.fmt.pix_mp.height = 720; 1712 f.fmt.pix_mp.field = V4L2_FIELD_NONE; 1713 vdec_s_fmt(file, &inst->fh, &f); 1714} 1715 1716static int vdec_open(struct file *file) 1717{ 1718 struct vpu_inst *inst; 1719 struct vdec_t *vdec; 1720 int ret; 1721 1722 inst = vzalloc(sizeof(*inst)); 1723 if (!inst) 1724 return -ENOMEM; 1725 1726 vdec = vzalloc(sizeof(*vdec)); 1727 if (!vdec) { 1728 vfree(inst); 1729 return -ENOMEM; 1730 } 1731 1732 inst->ops = &vdec_inst_ops; 1733 inst->formats = vdec_formats; 1734 inst->type = VPU_CORE_TYPE_DEC; 1735 inst->priv = vdec; 1736 1737 ret = vpu_v4l2_open(file, inst); 1738 if (ret) 1739 return ret; 1740 1741 vdec->fixed_fmt = false; 1742 vdec->state = VPU_CODEC_STATE_ACTIVE; 1743 inst->min_buffer_cap = VDEC_MIN_BUFFER_CAP; 1744 inst->min_buffer_out = VDEC_MIN_BUFFER_OUT; 1745 vdec_init(file); 1746 1747 return 0; 1748} 1749 1750static const struct v4l2_file_operations vdec_fops = { 1751 .owner = THIS_MODULE, 1752 .open = vdec_open, 1753 .release = vpu_v4l2_close, 1754 .unlocked_ioctl = video_ioctl2, 1755 .poll = v4l2_m2m_fop_poll, 1756 .mmap = v4l2_m2m_fop_mmap, 1757}; 1758 1759const struct v4l2_ioctl_ops *vdec_get_ioctl_ops(void) 1760{ 1761 return &vdec_ioctl_ops; 1762} 1763 1764const struct v4l2_file_operations *vdec_get_fops(void) 1765{ 1766 return &vdec_fops; 1767} 1768