1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 */ 5 6 #include <linux/pm_runtime.h> 7 #include <media/v4l2-event.h> 8 #include <media/v4l2-ioctl.h> 9 #include <media/v4l2-mem2mem.h> 10 #include <media/videobuf2-dma-contig.h> 11 12 #include "iris_vidc.h" 13 #include "iris_instance.h" 14 #include "iris_vdec.h" 15 #include "iris_venc.h" 16 #include "iris_vb2.h" 17 #include "iris_vpu_buffer.h" 18 #include "iris_platform_common.h" 19 20 #define IRIS_DRV_NAME "iris_driver" 21 #define IRIS_BUS_NAME "platform:iris_icc" 22 #define STEP_WIDTH 1 23 #define STEP_HEIGHT 1 24 25 static void iris_v4l2_fh_init(struct iris_inst *inst, struct file *filp) 26 { 27 if (inst->domain == ENCODER) 28 v4l2_fh_init(&inst->fh, inst->core->vdev_enc); 29 else if (inst->domain == DECODER) 30 v4l2_fh_init(&inst->fh, inst->core->vdev_dec); 31 inst->fh.ctrl_handler = &inst->ctrl_handler; 32 v4l2_fh_add(&inst->fh, filp); 33 } 34 35 static void iris_v4l2_fh_deinit(struct iris_inst *inst, struct file *filp) 36 { 37 v4l2_fh_del(&inst->fh, filp); 38 inst->fh.ctrl_handler = NULL; 39 v4l2_fh_exit(&inst->fh); 40 } 41 42 static void iris_add_session(struct iris_inst *inst) 43 { 44 struct iris_core *core = inst->core; 45 struct iris_inst *iter; 46 u32 count = 0; 47 48 mutex_lock(&core->lock); 49 50 list_for_each_entry(iter, &core->instances, list) 51 count++; 52 53 if (count < core->iris_platform_data->max_session_count) 54 list_add_tail(&inst->list, &core->instances); 55 56 mutex_unlock(&core->lock); 57 } 58 59 static void iris_remove_session(struct iris_inst *inst) 60 { 61 struct iris_core *core = inst->core; 62 struct iris_inst *iter, *temp; 63 64 mutex_lock(&core->lock); 65 list_for_each_entry_safe(iter, temp, &core->instances, list) { 66 if (iter->session_id == inst->session_id) { 67 list_del_init(&iter->list); 68 break; 69 } 70 } 71 mutex_unlock(&core->lock); 72 } 73 74 static inline struct iris_inst *iris_get_inst(struct file *filp) 75 { 76 return container_of(file_to_v4l2_fh(filp), struct iris_inst, fh); 77 } 78 79 static void iris_m2m_device_run(void *priv) 80 { 81 } 82 83 static void iris_m2m_job_abort(void *priv) 84 { 85 struct iris_inst *inst = priv; 86 struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx; 87 88 v4l2_m2m_job_finish(inst->m2m_dev, m2m_ctx); 89 } 90 91 static const struct v4l2_m2m_ops iris_m2m_ops = { 92 .device_run = iris_m2m_device_run, 93 .job_abort = iris_m2m_job_abort, 94 }; 95 96 static int 97 iris_m2m_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq) 98 { 99 struct iris_inst *inst = priv; 100 int ret; 101 102 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 103 src_vq->io_modes = VB2_MMAP | VB2_DMABUF; 104 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 105 src_vq->ops = inst->core->iris_vb2_ops; 106 src_vq->mem_ops = &vb2_dma_contig_memops; 107 src_vq->drv_priv = inst; 108 src_vq->buf_struct_size = sizeof(struct iris_buffer); 109 src_vq->min_reqbufs_allocation = MIN_BUFFERS; 110 src_vq->dev = inst->core->dev; 111 src_vq->lock = &inst->ctx_q_lock; 112 ret = vb2_queue_init(src_vq); 113 if (ret) 114 return ret; 115 116 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 117 dst_vq->io_modes = VB2_MMAP | VB2_DMABUF; 118 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 119 dst_vq->ops = inst->core->iris_vb2_ops; 120 dst_vq->mem_ops = &vb2_dma_contig_memops; 121 dst_vq->drv_priv = inst; 122 dst_vq->buf_struct_size = sizeof(struct iris_buffer); 123 dst_vq->min_reqbufs_allocation = MIN_BUFFERS; 124 dst_vq->dev = inst->core->dev; 125 dst_vq->lock = &inst->ctx_q_lock; 126 127 return vb2_queue_init(dst_vq); 128 } 129 130 int iris_open(struct file *filp) 131 { 132 struct iris_core *core = video_drvdata(filp); 133 struct video_device *vdev; 134 struct iris_inst *inst; 135 u32 session_type; 136 int ret; 137 138 vdev = video_devdata(filp); 139 if (strcmp(vdev->name, "qcom-iris-decoder") == 0) 140 session_type = DECODER; 141 else if (strcmp(vdev->name, "qcom-iris-encoder") == 0) 142 session_type = ENCODER; 143 else 144 return -EINVAL; 145 146 ret = pm_runtime_resume_and_get(core->dev); 147 if (ret < 0) 148 return ret; 149 150 ret = iris_core_init(core); 151 if (ret) { 152 dev_err(core->dev, "core init failed\n"); 153 pm_runtime_put_sync(core->dev); 154 return ret; 155 } 156 157 pm_runtime_put_sync(core->dev); 158 159 inst = core->iris_platform_data->get_instance(); 160 if (!inst) 161 return -ENOMEM; 162 163 inst->core = core; 164 inst->domain = session_type; 165 inst->session_id = hash32_ptr(inst); 166 inst->state = IRIS_INST_DEINIT; 167 168 mutex_init(&inst->lock); 169 mutex_init(&inst->ctx_q_lock); 170 171 INIT_LIST_HEAD(&inst->buffers[BUF_BIN].list); 172 INIT_LIST_HEAD(&inst->buffers[BUF_ARP].list); 173 INIT_LIST_HEAD(&inst->buffers[BUF_COMV].list); 174 INIT_LIST_HEAD(&inst->buffers[BUF_NON_COMV].list); 175 INIT_LIST_HEAD(&inst->buffers[BUF_LINE].list); 176 INIT_LIST_HEAD(&inst->buffers[BUF_DPB].list); 177 INIT_LIST_HEAD(&inst->buffers[BUF_PERSIST].list); 178 INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_1].list); 179 INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_2].list); 180 INIT_LIST_HEAD(&inst->buffers[BUF_VPSS].list); 181 INIT_LIST_HEAD(&inst->buffers[BUF_PARTIAL].list); 182 init_completion(&inst->completion); 183 init_completion(&inst->flush_completion); 184 185 iris_v4l2_fh_init(inst, filp); 186 187 inst->m2m_dev = v4l2_m2m_init(&iris_m2m_ops); 188 if (IS_ERR_OR_NULL(inst->m2m_dev)) { 189 ret = -EINVAL; 190 goto fail_v4l2_fh_deinit; 191 } 192 193 inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, iris_m2m_queue_init); 194 if (IS_ERR_OR_NULL(inst->m2m_ctx)) { 195 ret = -EINVAL; 196 goto fail_m2m_release; 197 } 198 199 if (inst->domain == DECODER) 200 ret = iris_vdec_inst_init(inst); 201 else if (inst->domain == ENCODER) 202 ret = iris_venc_inst_init(inst); 203 if (ret) 204 goto fail_m2m_ctx_release; 205 206 iris_add_session(inst); 207 208 inst->fh.m2m_ctx = inst->m2m_ctx; 209 210 return 0; 211 212 fail_m2m_ctx_release: 213 v4l2_m2m_ctx_release(inst->m2m_ctx); 214 fail_m2m_release: 215 v4l2_m2m_release(inst->m2m_dev); 216 fail_v4l2_fh_deinit: 217 iris_v4l2_fh_deinit(inst, filp); 218 mutex_destroy(&inst->ctx_q_lock); 219 mutex_destroy(&inst->lock); 220 kfree(inst); 221 222 return ret; 223 } 224 225 static void iris_session_close(struct iris_inst *inst) 226 { 227 const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops; 228 bool wait_for_response = true; 229 int ret; 230 231 if (inst->state == IRIS_INST_DEINIT) 232 return; 233 234 reinit_completion(&inst->completion); 235 236 ret = hfi_ops->session_close(inst); 237 if (ret) 238 wait_for_response = false; 239 240 if (wait_for_response) 241 iris_wait_for_session_response(inst, false); 242 } 243 244 static void iris_check_num_queued_internal_buffers(struct iris_inst *inst, u32 plane) 245 { 246 const struct iris_platform_data *platform_data = inst->core->iris_platform_data; 247 struct iris_buffer *buf, *next; 248 struct iris_buffers *buffers; 249 const u32 *internal_buf_type; 250 u32 internal_buffer_count, i; 251 u32 count = 0; 252 253 if (V4L2_TYPE_IS_OUTPUT(plane)) { 254 internal_buf_type = platform_data->dec_ip_int_buf_tbl; 255 internal_buffer_count = platform_data->dec_ip_int_buf_tbl_size; 256 } else { 257 internal_buf_type = platform_data->dec_op_int_buf_tbl; 258 internal_buffer_count = platform_data->dec_op_int_buf_tbl_size; 259 } 260 261 for (i = 0; i < internal_buffer_count; i++) { 262 buffers = &inst->buffers[internal_buf_type[i]]; 263 count = 0; 264 list_for_each_entry_safe(buf, next, &buffers->list, list) 265 count++; 266 if (count) 267 dev_err(inst->core->dev, "%d buffer of type %d not released", 268 count, internal_buf_type[i]); 269 } 270 271 if (inst->domain == DECODER) 272 buffers = &inst->buffers[BUF_PERSIST]; 273 else 274 buffers = &inst->buffers[BUF_ARP]; 275 276 count = 0; 277 list_for_each_entry_safe(buf, next, &buffers->list, list) 278 count++; 279 if (count) 280 dev_err(inst->core->dev, "%d buffer of type %d not released", 281 count, inst->domain == DECODER ? BUF_PERSIST : BUF_ARP); 282 } 283 284 int iris_close(struct file *filp) 285 { 286 struct iris_inst *inst = iris_get_inst(filp); 287 288 v4l2_ctrl_handler_free(&inst->ctrl_handler); 289 v4l2_m2m_ctx_release(inst->m2m_ctx); 290 v4l2_m2m_release(inst->m2m_dev); 291 mutex_lock(&inst->lock); 292 iris_session_close(inst); 293 iris_inst_change_state(inst, IRIS_INST_DEINIT); 294 iris_v4l2_fh_deinit(inst, filp); 295 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 296 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 297 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 298 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 299 iris_remove_session(inst); 300 mutex_unlock(&inst->lock); 301 mutex_destroy(&inst->ctx_q_lock); 302 mutex_destroy(&inst->lock); 303 kfree(inst->fmt_src); 304 kfree(inst->fmt_dst); 305 kfree(inst); 306 307 return 0; 308 } 309 310 static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f) 311 { 312 struct iris_inst *inst = iris_get_inst(filp); 313 314 if (inst->domain == DECODER) 315 return iris_vdec_enum_fmt(inst, f); 316 else if (inst->domain == ENCODER) 317 return iris_venc_enum_fmt(inst, f); 318 else 319 return -EINVAL; 320 } 321 322 static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 323 { 324 struct iris_inst *inst = iris_get_inst(filp); 325 int ret = 0; 326 327 mutex_lock(&inst->lock); 328 329 if (inst->domain == DECODER) 330 ret = iris_vdec_try_fmt(inst, f); 331 else if (inst->domain == ENCODER) 332 ret = iris_venc_try_fmt(inst, f); 333 334 mutex_unlock(&inst->lock); 335 336 return ret; 337 } 338 339 static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 340 { 341 struct iris_inst *inst = iris_get_inst(filp); 342 int ret = 0; 343 344 mutex_lock(&inst->lock); 345 346 if (inst->domain == DECODER) 347 ret = iris_vdec_s_fmt(inst, f); 348 else if (inst->domain == ENCODER) 349 ret = iris_venc_s_fmt(inst, f); 350 351 mutex_unlock(&inst->lock); 352 353 return ret; 354 } 355 356 static int iris_g_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 357 { 358 struct iris_inst *inst = iris_get_inst(filp); 359 int ret = 0; 360 361 mutex_lock(&inst->lock); 362 if (V4L2_TYPE_IS_OUTPUT(f->type)) 363 *f = *inst->fmt_src; 364 else if (V4L2_TYPE_IS_CAPTURE(f->type)) 365 *f = *inst->fmt_dst; 366 else 367 ret = -EINVAL; 368 369 mutex_unlock(&inst->lock); 370 371 return ret; 372 } 373 374 static int iris_enum_framesizes(struct file *filp, void *fh, 375 struct v4l2_frmsizeenum *fsize) 376 { 377 struct iris_inst *inst = iris_get_inst(filp); 378 struct platform_inst_caps *caps; 379 int ret = 0; 380 381 if (fsize->index) 382 return -EINVAL; 383 384 if (inst->domain == DECODER) 385 ret = iris_vdec_validate_format(inst, fsize->pixel_format); 386 else 387 ret = iris_venc_validate_format(inst, fsize->pixel_format); 388 389 if (ret) 390 return ret; 391 392 caps = inst->core->iris_platform_data->inst_caps; 393 394 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 395 fsize->stepwise.min_width = caps->min_frame_width; 396 fsize->stepwise.max_width = caps->max_frame_width; 397 fsize->stepwise.step_width = STEP_WIDTH; 398 fsize->stepwise.min_height = caps->min_frame_height; 399 fsize->stepwise.max_height = caps->max_frame_height; 400 fsize->stepwise.step_height = STEP_HEIGHT; 401 402 return ret; 403 } 404 405 static int iris_enum_frameintervals(struct file *filp, void *fh, 406 struct v4l2_frmivalenum *fival) 407 408 { 409 struct iris_inst *inst = iris_get_inst(filp); 410 struct iris_core *core = inst->core; 411 struct platform_inst_caps *caps; 412 u32 fps, mbpf; 413 int ret = 0; 414 415 if (inst->domain == DECODER) 416 return -ENOTTY; 417 418 if (fival->index) 419 return -EINVAL; 420 421 ret = iris_venc_validate_format(inst, fival->pixel_format); 422 if (ret) 423 return ret; 424 425 if (!fival->width || !fival->height) 426 return -EINVAL; 427 428 caps = inst->core->iris_platform_data->inst_caps; 429 if (fival->width > caps->max_frame_width || 430 fival->width < caps->min_frame_width || 431 fival->height > caps->max_frame_height || 432 fival->height < caps->min_frame_height) 433 return -EINVAL; 434 435 mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width); 436 fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf); 437 438 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE; 439 fival->stepwise.min.numerator = 1; 440 fival->stepwise.min.denominator = 441 min_t(u32, fps, MAXIMUM_FPS); 442 fival->stepwise.max.numerator = 1; 443 fival->stepwise.max.denominator = 1; 444 fival->stepwise.step.numerator = 1; 445 fival->stepwise.step.denominator = MAXIMUM_FPS; 446 447 return 0; 448 } 449 450 static int iris_querycap(struct file *filp, void *fh, struct v4l2_capability *cap) 451 { 452 struct iris_inst *inst = iris_get_inst(filp); 453 454 strscpy(cap->driver, IRIS_DRV_NAME, sizeof(cap->driver)); 455 456 if (inst->domain == DECODER) 457 strscpy(cap->card, "Iris Decoder", sizeof(cap->card)); 458 else 459 strscpy(cap->card, "Iris Encoder", sizeof(cap->card)); 460 461 return 0; 462 } 463 464 static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s) 465 { 466 struct iris_inst *inst = iris_get_inst(filp); 467 468 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 469 inst->domain == DECODER) 470 return -EINVAL; 471 472 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 473 inst->domain == ENCODER) 474 return -EINVAL; 475 476 if (inst->domain == DECODER) { 477 switch (s->target) { 478 case V4L2_SEL_TGT_CROP_BOUNDS: 479 case V4L2_SEL_TGT_CROP_DEFAULT: 480 case V4L2_SEL_TGT_CROP: 481 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 482 case V4L2_SEL_TGT_COMPOSE_PADDED: 483 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 484 case V4L2_SEL_TGT_COMPOSE: 485 s->r.left = inst->crop.left; 486 s->r.top = inst->crop.top; 487 s->r.width = inst->crop.width; 488 s->r.height = inst->crop.height; 489 break; 490 default: 491 return -EINVAL; 492 } 493 } else if (inst->domain == ENCODER) { 494 switch (s->target) { 495 case V4L2_SEL_TGT_CROP_BOUNDS: 496 case V4L2_SEL_TGT_CROP_DEFAULT: 497 s->r.width = inst->fmt_src->fmt.pix_mp.width; 498 s->r.height = inst->fmt_src->fmt.pix_mp.height; 499 break; 500 case V4L2_SEL_TGT_CROP: 501 s->r.width = inst->crop.width; 502 s->r.height = inst->crop.height; 503 break; 504 default: 505 return -EINVAL; 506 } 507 s->r.left = inst->crop.left; 508 s->r.top = inst->crop.top; 509 } 510 511 return 0; 512 } 513 514 static int iris_s_selection(struct file *filp, void *fh, struct v4l2_selection *s) 515 { 516 struct iris_inst *inst = iris_get_inst(filp); 517 518 if (inst->domain == DECODER) 519 return -EINVAL; 520 else if (inst->domain == ENCODER) 521 return iris_venc_s_selection(inst, s); 522 523 return -EINVAL; 524 } 525 526 static int iris_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) 527 { 528 struct iris_inst *inst = container_of(fh, struct iris_inst, fh); 529 530 if (inst->domain == DECODER) 531 return iris_vdec_subscribe_event(inst, sub); 532 else if (inst->domain == ENCODER) 533 return iris_venc_subscribe_event(inst, sub); 534 535 return -EINVAL; 536 } 537 538 static int iris_s_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 539 { 540 struct iris_inst *inst = iris_get_inst(filp); 541 542 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 543 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 544 return -EINVAL; 545 546 if (inst->domain == ENCODER) 547 return iris_venc_s_param(inst, a); 548 else 549 return -EINVAL; 550 } 551 552 static int iris_g_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 553 { 554 struct iris_inst *inst = iris_get_inst(filp); 555 556 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 557 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 558 return -EINVAL; 559 560 if (inst->domain == ENCODER) 561 return iris_venc_g_param(inst, a); 562 else 563 return -EINVAL; 564 } 565 566 static int iris_dec_cmd(struct file *filp, void *fh, 567 struct v4l2_decoder_cmd *dec) 568 { 569 struct iris_inst *inst = iris_get_inst(filp); 570 int ret = 0; 571 572 mutex_lock(&inst->lock); 573 574 if (dec->cmd != V4L2_DEC_CMD_STOP && dec->cmd != V4L2_DEC_CMD_START) { 575 ret = -EINVAL; 576 goto unlock; 577 } 578 579 if (inst->state == IRIS_INST_DEINIT) 580 goto unlock; 581 582 if (!iris_allow_cmd(inst, dec->cmd)) { 583 ret = -EBUSY; 584 goto unlock; 585 } 586 587 if (dec->cmd == V4L2_DEC_CMD_START) 588 ret = iris_vdec_start_cmd(inst); 589 else if (dec->cmd == V4L2_DEC_CMD_STOP) 590 ret = iris_vdec_stop_cmd(inst); 591 else 592 ret = -EINVAL; 593 594 unlock: 595 mutex_unlock(&inst->lock); 596 597 return ret; 598 } 599 600 static int iris_enc_cmd(struct file *filp, void *fh, 601 struct v4l2_encoder_cmd *enc) 602 { 603 struct iris_inst *inst = iris_get_inst(filp); 604 int ret = 0; 605 606 mutex_lock(&inst->lock); 607 608 if (enc->cmd != V4L2_ENC_CMD_STOP && enc->cmd != V4L2_ENC_CMD_START) { 609 ret = -EINVAL; 610 goto unlock; 611 } 612 613 if (inst->state == IRIS_INST_DEINIT) 614 goto unlock; 615 616 if (!iris_allow_cmd(inst, enc->cmd)) { 617 ret = -EBUSY; 618 goto unlock; 619 } 620 621 if (enc->cmd == V4L2_ENC_CMD_START) 622 ret = iris_venc_start_cmd(inst); 623 else if (enc->cmd == V4L2_ENC_CMD_STOP) 624 ret = iris_venc_stop_cmd(inst); 625 else 626 ret = -EINVAL; 627 628 unlock: 629 mutex_unlock(&inst->lock); 630 631 return ret; 632 } 633 634 static const struct v4l2_file_operations iris_v4l2_file_ops = { 635 .owner = THIS_MODULE, 636 .open = iris_open, 637 .release = iris_close, 638 .unlocked_ioctl = video_ioctl2, 639 .poll = v4l2_m2m_fop_poll, 640 .mmap = v4l2_m2m_fop_mmap, 641 }; 642 643 static const struct vb2_ops iris_vb2_ops = { 644 .buf_init = iris_vb2_buf_init, 645 .queue_setup = iris_vb2_queue_setup, 646 .start_streaming = iris_vb2_start_streaming, 647 .stop_streaming = iris_vb2_stop_streaming, 648 .buf_prepare = iris_vb2_buf_prepare, 649 .buf_out_validate = iris_vb2_buf_out_validate, 650 .buf_queue = iris_vb2_buf_queue, 651 }; 652 653 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_dec = { 654 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 655 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 656 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 657 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 658 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 659 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 660 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 661 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 662 .vidioc_enum_framesizes = iris_enum_framesizes, 663 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 664 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 665 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 666 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 667 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 668 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 669 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 670 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 671 .vidioc_querycap = iris_querycap, 672 .vidioc_g_selection = iris_g_selection, 673 .vidioc_subscribe_event = iris_subscribe_event, 674 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 675 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 676 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 677 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 678 .vidioc_decoder_cmd = iris_dec_cmd, 679 }; 680 681 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = { 682 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 683 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 684 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 685 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 686 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 687 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 688 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 689 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 690 .vidioc_enum_framesizes = iris_enum_framesizes, 691 .vidioc_enum_frameintervals = iris_enum_frameintervals, 692 .vidioc_querycap = iris_querycap, 693 .vidioc_subscribe_event = iris_subscribe_event, 694 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 695 .vidioc_g_selection = iris_g_selection, 696 .vidioc_s_selection = iris_s_selection, 697 .vidioc_s_parm = iris_s_parm, 698 .vidioc_g_parm = iris_g_parm, 699 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 700 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 701 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 702 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 703 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 704 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 705 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 706 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 707 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 708 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 709 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 710 .vidioc_encoder_cmd = iris_enc_cmd, 711 }; 712 713 void iris_init_ops(struct iris_core *core) 714 { 715 core->iris_v4l2_file_ops = &iris_v4l2_file_ops; 716 core->iris_vb2_ops = &iris_vb2_ops; 717 core->iris_v4l2_ioctl_ops_dec = &iris_v4l2_ioctl_ops_dec; 718 core->iris_v4l2_ioctl_ops_enc = &iris_v4l2_ioctl_ops_enc; 719 } 720