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