1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2022-2025 Qualcomm Innovation Center, Inc. All rights reserved. 4 */ 5 6 #include <media/v4l2-event.h> 7 #include <media/v4l2-mem2mem.h> 8 9 #include "iris_buffer.h" 10 #include "iris_common.h" 11 #include "iris_ctrls.h" 12 #include "iris_instance.h" 13 #include "iris_power.h" 14 #include "iris_venc.h" 15 #include "iris_vpu_buffer.h" 16 17 int iris_venc_inst_init(struct iris_inst *inst) 18 { 19 struct iris_core *core = inst->core; 20 struct v4l2_format *f; 21 22 inst->fmt_src = kzalloc(sizeof(*inst->fmt_src), GFP_KERNEL); 23 inst->fmt_dst = kzalloc(sizeof(*inst->fmt_dst), GFP_KERNEL); 24 if (!inst->fmt_src || !inst->fmt_dst) { 25 kfree(inst->fmt_src); 26 kfree(inst->fmt_dst); 27 return -ENOMEM; 28 } 29 30 f = inst->fmt_dst; 31 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 32 f->fmt.pix_mp.width = DEFAULT_WIDTH; 33 f->fmt.pix_mp.height = DEFAULT_HEIGHT; 34 f->fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264; 35 inst->codec = f->fmt.pix_mp.pixelformat; 36 f->fmt.pix_mp.num_planes = 1; 37 f->fmt.pix_mp.plane_fmt[0].bytesperline = 0; 38 f->fmt.pix_mp.plane_fmt[0].sizeimage = iris_get_buffer_size(inst, BUF_OUTPUT); 39 f->fmt.pix_mp.field = V4L2_FIELD_NONE; 40 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT; 41 f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT; 42 f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 43 f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT; 44 inst->buffers[BUF_OUTPUT].min_count = iris_vpu_buf_count(inst, BUF_OUTPUT); 45 inst->buffers[BUF_OUTPUT].size = f->fmt.pix_mp.plane_fmt[0].sizeimage; 46 47 f = inst->fmt_src; 48 f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 49 f->fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12; 50 f->fmt.pix_mp.width = ALIGN(DEFAULT_WIDTH, 128); 51 f->fmt.pix_mp.height = ALIGN(DEFAULT_HEIGHT, 32); 52 f->fmt.pix_mp.num_planes = 1; 53 f->fmt.pix_mp.plane_fmt[0].bytesperline = ALIGN(DEFAULT_WIDTH, 128); 54 f->fmt.pix_mp.plane_fmt[0].sizeimage = iris_get_buffer_size(inst, BUF_INPUT); 55 f->fmt.pix_mp.field = V4L2_FIELD_NONE; 56 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT; 57 f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT; 58 f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 59 f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT; 60 inst->buffers[BUF_INPUT].min_count = iris_vpu_buf_count(inst, BUF_INPUT); 61 inst->buffers[BUF_INPUT].size = f->fmt.pix_mp.plane_fmt[0].sizeimage; 62 63 inst->crop.left = 0; 64 inst->crop.top = 0; 65 inst->crop.width = f->fmt.pix_mp.width; 66 inst->crop.height = f->fmt.pix_mp.height; 67 68 inst->operating_rate = DEFAULT_FPS; 69 inst->frame_rate = DEFAULT_FPS; 70 71 memcpy(&inst->fw_caps[0], &core->inst_fw_caps_enc[0], 72 INST_FW_CAP_MAX * sizeof(struct platform_inst_fw_cap)); 73 74 return iris_ctrls_init(inst); 75 } 76 77 void iris_venc_inst_deinit(struct iris_inst *inst) 78 { 79 kfree(inst->fmt_dst); 80 kfree(inst->fmt_src); 81 } 82 83 static const struct iris_fmt iris_venc_formats_cap[] = { 84 [IRIS_FMT_H264] = { 85 .pixfmt = V4L2_PIX_FMT_H264, 86 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, 87 }, 88 [IRIS_FMT_HEVC] = { 89 .pixfmt = V4L2_PIX_FMT_HEVC, 90 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, 91 }, 92 }; 93 94 static const struct iris_fmt iris_venc_formats_out[] = { 95 [IRIS_FMT_NV12] = { 96 .pixfmt = V4L2_PIX_FMT_NV12, 97 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, 98 }, 99 [IRIS_FMT_QC08C] = { 100 .pixfmt = V4L2_PIX_FMT_QC08C, 101 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, 102 }, 103 }; 104 105 static const struct iris_fmt * 106 find_format(struct iris_inst *inst, u32 pixfmt, u32 type) 107 { 108 const struct iris_fmt *fmt = NULL; 109 unsigned int size = 0; 110 unsigned int i; 111 switch (type) { 112 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 113 fmt = iris_venc_formats_out; 114 size = ARRAY_SIZE(iris_venc_formats_out); 115 break; 116 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 117 fmt = iris_venc_formats_cap; 118 size = ARRAY_SIZE(iris_venc_formats_cap); 119 break; 120 default: 121 return NULL; 122 } 123 124 for (i = 0; i < size; i++) { 125 if (fmt[i].pixfmt == pixfmt) 126 break; 127 } 128 129 if (i == size || fmt[i].type != type) 130 return NULL; 131 132 return &fmt[i]; 133 } 134 135 static const struct iris_fmt * 136 find_format_by_index(struct iris_inst *inst, u32 index, u32 type) 137 { 138 const struct iris_fmt *fmt = NULL; 139 unsigned int size = 0; 140 141 switch (type) { 142 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 143 fmt = iris_venc_formats_out; 144 size = ARRAY_SIZE(iris_venc_formats_out); 145 break; 146 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 147 fmt = iris_venc_formats_cap; 148 size = ARRAY_SIZE(iris_venc_formats_cap); 149 break; 150 default: 151 return NULL; 152 } 153 154 if (index >= size || fmt[index].type != type) 155 return NULL; 156 157 return &fmt[index]; 158 } 159 160 int iris_venc_enum_fmt(struct iris_inst *inst, struct v4l2_fmtdesc *f) 161 { 162 const struct iris_fmt *fmt; 163 164 switch (f->type) { 165 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 166 fmt = find_format_by_index(inst, f->index, f->type); 167 if (!fmt) 168 return -EINVAL; 169 170 f->pixelformat = fmt->pixfmt; 171 break; 172 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 173 fmt = find_format_by_index(inst, f->index, f->type); 174 if (!fmt) 175 return -EINVAL; 176 177 f->pixelformat = fmt->pixfmt; 178 f->flags = V4L2_FMT_FLAG_COMPRESSED | V4L2_FMT_FLAG_ENC_CAP_FRAME_INTERVAL; 179 break; 180 default: 181 return -EINVAL; 182 } 183 184 return 0; 185 } 186 187 int iris_venc_try_fmt(struct iris_inst *inst, struct v4l2_format *f) 188 { 189 struct v4l2_pix_format_mplane *pixmp = &f->fmt.pix_mp; 190 const struct iris_fmt *fmt; 191 struct v4l2_format *f_inst; 192 193 memset(pixmp->reserved, 0, sizeof(pixmp->reserved)); 194 fmt = find_format(inst, pixmp->pixelformat, f->type); 195 switch (f->type) { 196 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 197 if (!fmt) { 198 f_inst = inst->fmt_src; 199 f->fmt.pix_mp.width = f_inst->fmt.pix_mp.width; 200 f->fmt.pix_mp.height = f_inst->fmt.pix_mp.height; 201 f->fmt.pix_mp.pixelformat = f_inst->fmt.pix_mp.pixelformat; 202 } 203 break; 204 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 205 if (!fmt) { 206 f_inst = inst->fmt_dst; 207 f->fmt.pix_mp.width = f_inst->fmt.pix_mp.width; 208 f->fmt.pix_mp.height = f_inst->fmt.pix_mp.height; 209 f->fmt.pix_mp.pixelformat = f_inst->fmt.pix_mp.pixelformat; 210 } 211 break; 212 default: 213 return -EINVAL; 214 } 215 216 if (pixmp->field == V4L2_FIELD_ANY) 217 pixmp->field = V4L2_FIELD_NONE; 218 219 pixmp->num_planes = 1; 220 221 return 0; 222 } 223 224 static int iris_venc_s_fmt_output(struct iris_inst *inst, struct v4l2_format *f) 225 { 226 struct v4l2_format *fmt; 227 228 iris_venc_try_fmt(inst, f); 229 230 if (!(find_format(inst, f->fmt.pix_mp.pixelformat, f->type))) 231 return -EINVAL; 232 233 fmt = inst->fmt_dst; 234 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 235 fmt->fmt.pix_mp.num_planes = 1; 236 fmt->fmt.pix_mp.plane_fmt[0].bytesperline = 0; 237 fmt->fmt.pix_mp.plane_fmt[0].sizeimage = iris_get_buffer_size(inst, BUF_OUTPUT); 238 239 if (f->fmt.pix_mp.colorspace != V4L2_COLORSPACE_DEFAULT && 240 f->fmt.pix_mp.colorspace != V4L2_COLORSPACE_REC709) 241 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_DEFAULT; 242 fmt->fmt.pix_mp.colorspace = f->fmt.pix_mp.colorspace; 243 fmt->fmt.pix_mp.xfer_func = f->fmt.pix_mp.xfer_func; 244 fmt->fmt.pix_mp.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc; 245 fmt->fmt.pix_mp.quantization = f->fmt.pix_mp.quantization; 246 247 inst->buffers[BUF_OUTPUT].min_count = iris_vpu_buf_count(inst, BUF_OUTPUT); 248 inst->buffers[BUF_OUTPUT].size = fmt->fmt.pix_mp.plane_fmt[0].sizeimage; 249 fmt->fmt.pix_mp.pixelformat = f->fmt.pix_mp.pixelformat; 250 inst->codec = f->fmt.pix_mp.pixelformat; 251 memcpy(f, fmt, sizeof(struct v4l2_format)); 252 253 return 0; 254 } 255 256 static int iris_venc_s_fmt_input(struct iris_inst *inst, struct v4l2_format *f) 257 { 258 struct v4l2_format *fmt, *output_fmt; 259 260 iris_venc_try_fmt(inst, f); 261 262 if (!(find_format(inst, f->fmt.pix_mp.pixelformat, f->type))) 263 return -EINVAL; 264 265 fmt = inst->fmt_src; 266 fmt->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 267 fmt->fmt.pix_mp.width = ALIGN(f->fmt.pix_mp.width, 128); 268 fmt->fmt.pix_mp.height = ALIGN(f->fmt.pix_mp.height, 32); 269 fmt->fmt.pix_mp.num_planes = 1; 270 fmt->fmt.pix_mp.pixelformat = f->fmt.pix_mp.pixelformat; 271 fmt->fmt.pix_mp.plane_fmt[0].bytesperline = ALIGN(f->fmt.pix_mp.width, 128); 272 fmt->fmt.pix_mp.plane_fmt[0].sizeimage = iris_get_buffer_size(inst, BUF_INPUT); 273 274 fmt->fmt.pix_mp.colorspace = f->fmt.pix_mp.colorspace; 275 fmt->fmt.pix_mp.xfer_func = f->fmt.pix_mp.xfer_func; 276 fmt->fmt.pix_mp.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc; 277 fmt->fmt.pix_mp.quantization = f->fmt.pix_mp.quantization; 278 279 output_fmt = inst->fmt_dst; 280 output_fmt->fmt.pix_mp.width = fmt->fmt.pix_mp.width; 281 output_fmt->fmt.pix_mp.height = fmt->fmt.pix_mp.height; 282 output_fmt->fmt.pix_mp.colorspace = fmt->fmt.pix_mp.colorspace; 283 output_fmt->fmt.pix_mp.xfer_func = fmt->fmt.pix_mp.xfer_func; 284 output_fmt->fmt.pix_mp.ycbcr_enc = fmt->fmt.pix_mp.ycbcr_enc; 285 output_fmt->fmt.pix_mp.quantization = fmt->fmt.pix_mp.quantization; 286 287 inst->buffers[BUF_INPUT].min_count = iris_vpu_buf_count(inst, BUF_INPUT); 288 inst->buffers[BUF_INPUT].size = fmt->fmt.pix_mp.plane_fmt[0].sizeimage; 289 290 if (f->fmt.pix_mp.width != inst->crop.width || 291 f->fmt.pix_mp.height != inst->crop.height) { 292 inst->crop.top = 0; 293 inst->crop.left = 0; 294 inst->crop.width = fmt->fmt.pix_mp.width; 295 inst->crop.height = fmt->fmt.pix_mp.height; 296 297 iris_venc_s_fmt_output(inst, output_fmt); 298 } 299 300 memcpy(f, fmt, sizeof(struct v4l2_format)); 301 302 return 0; 303 } 304 305 int iris_venc_s_fmt(struct iris_inst *inst, struct v4l2_format *f) 306 { 307 struct vb2_queue *q; 308 309 q = v4l2_m2m_get_vq(inst->m2m_ctx, f->type); 310 311 if (vb2_is_busy(q)) 312 return -EBUSY; 313 314 switch (f->type) { 315 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 316 return iris_venc_s_fmt_input(inst, f); 317 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 318 return iris_venc_s_fmt_output(inst, f); 319 default: 320 return -EINVAL; 321 } 322 } 323 324 int iris_venc_validate_format(struct iris_inst *inst, u32 pixelformat) 325 { 326 const struct iris_fmt *fmt = NULL; 327 328 fmt = find_format(inst, pixelformat, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 329 if (!fmt) { 330 fmt = find_format(inst, pixelformat, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 331 if (!fmt) 332 return -EINVAL; 333 } 334 335 return 0; 336 } 337 338 int iris_venc_subscribe_event(struct iris_inst *inst, 339 const struct v4l2_event_subscription *sub) 340 { 341 switch (sub->type) { 342 case V4L2_EVENT_EOS: 343 return v4l2_event_subscribe(&inst->fh, sub, 0, NULL); 344 case V4L2_EVENT_CTRL: 345 return v4l2_ctrl_subscribe_event(&inst->fh, sub); 346 default: 347 return -EINVAL; 348 } 349 } 350 351 int iris_venc_s_selection(struct iris_inst *inst, struct v4l2_selection *s) 352 { 353 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 354 return -EINVAL; 355 356 switch (s->target) { 357 case V4L2_SEL_TGT_CROP: 358 s->r.left = 0; 359 s->r.top = 0; 360 361 if (s->r.width > inst->fmt_src->fmt.pix_mp.width || 362 s->r.height > inst->fmt_src->fmt.pix_mp.height) 363 return -EINVAL; 364 365 inst->crop.left = s->r.left; 366 inst->crop.top = s->r.top; 367 inst->crop.width = s->r.width; 368 inst->crop.height = s->r.height; 369 inst->fmt_dst->fmt.pix_mp.width = inst->crop.width; 370 inst->fmt_dst->fmt.pix_mp.height = inst->crop.height; 371 return iris_venc_s_fmt_output(inst, inst->fmt_dst); 372 default: 373 return -EINVAL; 374 } 375 } 376 377 int iris_venc_s_param(struct iris_inst *inst, struct v4l2_streamparm *s_parm) 378 { 379 struct platform_inst_caps *caps = inst->core->iris_platform_data->inst_caps; 380 struct vb2_queue *src_q = v4l2_m2m_get_src_vq(inst->m2m_ctx); 381 struct vb2_queue *dst_q = v4l2_m2m_get_dst_vq(inst->m2m_ctx); 382 struct v4l2_fract *timeperframe = NULL; 383 u32 default_rate = DEFAULT_FPS; 384 bool is_frame_rate = false; 385 u64 us_per_frame, fps; 386 u32 max_rate; 387 388 int ret = 0; 389 390 if (s_parm->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 391 timeperframe = &s_parm->parm.output.timeperframe; 392 max_rate = caps->max_operating_rate; 393 s_parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 394 } else { 395 timeperframe = &s_parm->parm.capture.timeperframe; 396 is_frame_rate = true; 397 max_rate = caps->max_frame_rate; 398 s_parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 399 } 400 401 if (!timeperframe->denominator || !timeperframe->numerator) { 402 if (!timeperframe->numerator) 403 timeperframe->numerator = 1; 404 if (!timeperframe->denominator) 405 timeperframe->denominator = default_rate; 406 } 407 408 us_per_frame = timeperframe->numerator * (u64)USEC_PER_SEC; 409 do_div(us_per_frame, timeperframe->denominator); 410 411 if (!us_per_frame) 412 return -EINVAL; 413 414 fps = (u64)USEC_PER_SEC; 415 do_div(fps, us_per_frame); 416 if (fps > max_rate) { 417 ret = -ENOMEM; 418 goto reset_rate; 419 } 420 421 if (is_frame_rate) 422 inst->frame_rate = (u32)fps; 423 else 424 inst->operating_rate = (u32)fps; 425 426 if ((s_parm->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE && vb2_is_streaming(src_q)) || 427 (s_parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && vb2_is_streaming(dst_q))) { 428 ret = iris_check_core_mbpf(inst); 429 if (ret) 430 goto reset_rate; 431 ret = iris_check_core_mbps(inst); 432 if (ret) 433 goto reset_rate; 434 } 435 436 return 0; 437 438 reset_rate: 439 if (ret) { 440 if (is_frame_rate) 441 inst->frame_rate = default_rate; 442 else 443 inst->operating_rate = default_rate; 444 } 445 446 return ret; 447 } 448 449 int iris_venc_g_param(struct iris_inst *inst, struct v4l2_streamparm *s_parm) 450 { 451 struct v4l2_fract *timeperframe = NULL; 452 453 if (s_parm->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { 454 timeperframe = &s_parm->parm.output.timeperframe; 455 timeperframe->numerator = 1; 456 timeperframe->denominator = inst->operating_rate; 457 s_parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 458 } else { 459 timeperframe = &s_parm->parm.capture.timeperframe; 460 timeperframe->numerator = 1; 461 timeperframe->denominator = inst->frame_rate; 462 s_parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 463 } 464 465 return 0; 466 } 467 468 int iris_venc_streamon_input(struct iris_inst *inst) 469 { 470 int ret; 471 472 ret = iris_set_properties(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 473 if (ret) 474 return ret; 475 476 ret = iris_alloc_and_queue_persist_bufs(inst, BUF_ARP); 477 if (ret) 478 return ret; 479 480 iris_get_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 481 482 ret = iris_destroy_dequeued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 483 if (ret) 484 return ret; 485 486 ret = iris_create_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 487 if (ret) 488 return ret; 489 490 ret = iris_queue_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 491 if (ret) 492 return ret; 493 494 return iris_process_streamon_input(inst); 495 } 496 497 int iris_venc_streamon_output(struct iris_inst *inst) 498 { 499 int ret; 500 501 ret = iris_set_properties(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 502 if (ret) 503 goto error; 504 505 ret = iris_alloc_and_queue_persist_bufs(inst, BUF_ARP); 506 if (ret) 507 return ret; 508 509 iris_get_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 510 511 ret = iris_destroy_dequeued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 512 if (ret) 513 goto error; 514 515 ret = iris_create_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 516 if (ret) 517 goto error; 518 519 ret = iris_queue_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 520 if (ret) 521 goto error; 522 523 ret = iris_process_streamon_output(inst); 524 if (ret) 525 goto error; 526 527 return ret; 528 529 error: 530 iris_session_streamoff(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 531 532 return ret; 533 } 534 535 int iris_venc_qbuf(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf) 536 { 537 struct iris_buffer *buf = to_iris_buffer(vbuf); 538 struct vb2_buffer *vb2 = &vbuf->vb2_buf; 539 struct vb2_queue *q; 540 int ret; 541 542 ret = iris_vb2_buffer_to_driver(vb2, buf); 543 if (ret) 544 return ret; 545 546 if (buf->type == BUF_INPUT) 547 iris_set_ts_metadata(inst, vbuf); 548 549 q = v4l2_m2m_get_vq(inst->m2m_ctx, vb2->type); 550 if (!vb2_is_streaming(q)) { 551 buf->attr |= BUF_ATTR_DEFERRED; 552 return 0; 553 } 554 555 iris_scale_power(inst); 556 557 return iris_queue_buffer(inst, buf); 558 } 559 560 int iris_venc_start_cmd(struct iris_inst *inst) 561 { 562 const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops; 563 enum iris_inst_sub_state clear_sub_state = 0; 564 struct vb2_queue *dst_vq; 565 int ret; 566 567 dst_vq = v4l2_m2m_get_dst_vq(inst->m2m_ctx); 568 569 if (inst->sub_state & IRIS_INST_SUB_DRAIN && 570 inst->sub_state & IRIS_INST_SUB_DRAIN_LAST) { 571 vb2_clear_last_buffer_dequeued(dst_vq); 572 clear_sub_state = IRIS_INST_SUB_DRAIN | IRIS_INST_SUB_DRAIN_LAST; 573 if (inst->sub_state & IRIS_INST_SUB_INPUT_PAUSE) { 574 if (hfi_ops->session_resume_drain) { 575 ret = hfi_ops->session_resume_drain(inst, 576 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 577 if (ret) 578 return ret; 579 } 580 clear_sub_state |= IRIS_INST_SUB_INPUT_PAUSE; 581 } 582 if (inst->sub_state & IRIS_INST_SUB_OUTPUT_PAUSE) { 583 if (hfi_ops->session_resume_drain) { 584 ret = hfi_ops->session_resume_drain(inst, 585 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 586 if (ret) 587 return ret; 588 } 589 clear_sub_state |= IRIS_INST_SUB_OUTPUT_PAUSE; 590 } 591 } else { 592 dev_err(inst->core->dev, "start called before receiving last_flag\n"); 593 iris_inst_change_state(inst, IRIS_INST_ERROR); 594 return -EBUSY; 595 } 596 597 inst->last_buffer_dequeued = false; 598 599 return iris_inst_change_sub_state(inst, clear_sub_state, 0); 600 } 601 602 int iris_venc_stop_cmd(struct iris_inst *inst) 603 { 604 const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops; 605 int ret; 606 607 ret = hfi_ops->session_drain(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 608 if (ret) 609 return ret; 610 611 ret = iris_inst_change_sub_state(inst, 0, IRIS_INST_SUB_DRAIN); 612 613 iris_scale_power(inst); 614 615 return ret; 616 } 617