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 if (inst->domain == DECODER) 293 iris_vdec_inst_deinit(inst); 294 else if (inst->domain == ENCODER) 295 iris_venc_inst_deinit(inst); 296 iris_session_close(inst); 297 iris_inst_change_state(inst, IRIS_INST_DEINIT); 298 iris_v4l2_fh_deinit(inst, filp); 299 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 300 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 301 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 302 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 303 iris_remove_session(inst); 304 mutex_unlock(&inst->lock); 305 mutex_destroy(&inst->ctx_q_lock); 306 mutex_destroy(&inst->lock); 307 kfree(inst); 308 309 return 0; 310 } 311 312 static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f) 313 { 314 struct iris_inst *inst = iris_get_inst(filp); 315 316 if (inst->domain == DECODER) 317 return iris_vdec_enum_fmt(inst, f); 318 else if (inst->domain == ENCODER) 319 return iris_venc_enum_fmt(inst, f); 320 else 321 return -EINVAL; 322 } 323 324 static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 325 { 326 struct iris_inst *inst = iris_get_inst(filp); 327 int ret = 0; 328 329 mutex_lock(&inst->lock); 330 331 if (inst->domain == DECODER) 332 ret = iris_vdec_try_fmt(inst, f); 333 else if (inst->domain == ENCODER) 334 ret = iris_venc_try_fmt(inst, f); 335 336 mutex_unlock(&inst->lock); 337 338 return ret; 339 } 340 341 static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 342 { 343 struct iris_inst *inst = iris_get_inst(filp); 344 int ret = 0; 345 346 mutex_lock(&inst->lock); 347 348 if (inst->domain == DECODER) 349 ret = iris_vdec_s_fmt(inst, f); 350 else if (inst->domain == ENCODER) 351 ret = iris_venc_s_fmt(inst, f); 352 353 mutex_unlock(&inst->lock); 354 355 return ret; 356 } 357 358 static int iris_g_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 359 { 360 struct iris_inst *inst = iris_get_inst(filp); 361 int ret = 0; 362 363 mutex_lock(&inst->lock); 364 if (V4L2_TYPE_IS_OUTPUT(f->type)) 365 *f = *inst->fmt_src; 366 else if (V4L2_TYPE_IS_CAPTURE(f->type)) 367 *f = *inst->fmt_dst; 368 else 369 ret = -EINVAL; 370 371 mutex_unlock(&inst->lock); 372 373 return ret; 374 } 375 376 static int iris_enum_framesizes(struct file *filp, void *fh, 377 struct v4l2_frmsizeenum *fsize) 378 { 379 struct iris_inst *inst = iris_get_inst(filp); 380 struct platform_inst_caps *caps; 381 int ret = 0; 382 383 if (fsize->index) 384 return -EINVAL; 385 386 if (inst->domain == DECODER) 387 ret = iris_vdec_validate_format(inst, fsize->pixel_format); 388 else 389 ret = iris_venc_validate_format(inst, fsize->pixel_format); 390 391 if (ret) 392 return ret; 393 394 caps = inst->core->iris_platform_data->inst_caps; 395 396 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 397 fsize->stepwise.min_width = caps->min_frame_width; 398 fsize->stepwise.max_width = caps->max_frame_width; 399 fsize->stepwise.step_width = STEP_WIDTH; 400 fsize->stepwise.min_height = caps->min_frame_height; 401 fsize->stepwise.max_height = caps->max_frame_height; 402 fsize->stepwise.step_height = STEP_HEIGHT; 403 404 return ret; 405 } 406 407 static int iris_enum_frameintervals(struct file *filp, void *fh, 408 struct v4l2_frmivalenum *fival) 409 410 { 411 struct iris_inst *inst = iris_get_inst(filp); 412 struct iris_core *core = inst->core; 413 struct platform_inst_caps *caps; 414 u32 fps, mbpf; 415 int ret = 0; 416 417 if (inst->domain == DECODER) 418 return -ENOTTY; 419 420 if (fival->index) 421 return -EINVAL; 422 423 ret = iris_venc_validate_format(inst, fival->pixel_format); 424 if (ret) 425 return ret; 426 427 if (!fival->width || !fival->height) 428 return -EINVAL; 429 430 caps = inst->core->iris_platform_data->inst_caps; 431 if (fival->width > caps->max_frame_width || 432 fival->width < caps->min_frame_width || 433 fival->height > caps->max_frame_height || 434 fival->height < caps->min_frame_height) 435 return -EINVAL; 436 437 mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width); 438 fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf); 439 440 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE; 441 fival->stepwise.min.numerator = 1; 442 fival->stepwise.min.denominator = 443 min_t(u32, fps, MAXIMUM_FPS); 444 fival->stepwise.max.numerator = 1; 445 fival->stepwise.max.denominator = 1; 446 fival->stepwise.step.numerator = 1; 447 fival->stepwise.step.denominator = MAXIMUM_FPS; 448 449 return 0; 450 } 451 452 static int iris_querycap(struct file *filp, void *fh, struct v4l2_capability *cap) 453 { 454 struct iris_inst *inst = iris_get_inst(filp); 455 456 strscpy(cap->driver, IRIS_DRV_NAME, sizeof(cap->driver)); 457 458 if (inst->domain == DECODER) 459 strscpy(cap->card, "Iris Decoder", sizeof(cap->card)); 460 else 461 strscpy(cap->card, "Iris Encoder", sizeof(cap->card)); 462 463 return 0; 464 } 465 466 static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s) 467 { 468 struct iris_inst *inst = iris_get_inst(filp); 469 470 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 471 inst->domain == DECODER) 472 return -EINVAL; 473 474 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 475 inst->domain == ENCODER) 476 return -EINVAL; 477 478 if (inst->domain == DECODER) { 479 switch (s->target) { 480 case V4L2_SEL_TGT_CROP_BOUNDS: 481 case V4L2_SEL_TGT_CROP_DEFAULT: 482 case V4L2_SEL_TGT_CROP: 483 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 484 case V4L2_SEL_TGT_COMPOSE_PADDED: 485 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 486 case V4L2_SEL_TGT_COMPOSE: 487 s->r.left = inst->crop.left; 488 s->r.top = inst->crop.top; 489 s->r.width = inst->crop.width; 490 s->r.height = inst->crop.height; 491 break; 492 default: 493 return -EINVAL; 494 } 495 } else if (inst->domain == ENCODER) { 496 switch (s->target) { 497 case V4L2_SEL_TGT_CROP_BOUNDS: 498 case V4L2_SEL_TGT_CROP_DEFAULT: 499 s->r.width = inst->fmt_src->fmt.pix_mp.width; 500 s->r.height = inst->fmt_src->fmt.pix_mp.height; 501 break; 502 case V4L2_SEL_TGT_CROP: 503 s->r.width = inst->crop.width; 504 s->r.height = inst->crop.height; 505 break; 506 default: 507 return -EINVAL; 508 } 509 s->r.left = inst->crop.left; 510 s->r.top = inst->crop.top; 511 } 512 513 return 0; 514 } 515 516 static int iris_s_selection(struct file *filp, void *fh, struct v4l2_selection *s) 517 { 518 struct iris_inst *inst = iris_get_inst(filp); 519 520 if (inst->domain == DECODER) 521 return -EINVAL; 522 else if (inst->domain == ENCODER) 523 return iris_venc_s_selection(inst, s); 524 525 return -EINVAL; 526 } 527 528 static int iris_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) 529 { 530 struct iris_inst *inst = container_of(fh, struct iris_inst, fh); 531 532 if (inst->domain == DECODER) 533 return iris_vdec_subscribe_event(inst, sub); 534 else if (inst->domain == ENCODER) 535 return iris_venc_subscribe_event(inst, sub); 536 537 return -EINVAL; 538 } 539 540 static int iris_s_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 541 { 542 struct iris_inst *inst = iris_get_inst(filp); 543 544 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 545 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 546 return -EINVAL; 547 548 if (inst->domain == ENCODER) 549 return iris_venc_s_param(inst, a); 550 else 551 return -EINVAL; 552 } 553 554 static int iris_g_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 555 { 556 struct iris_inst *inst = iris_get_inst(filp); 557 558 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 559 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 560 return -EINVAL; 561 562 if (inst->domain == ENCODER) 563 return iris_venc_g_param(inst, a); 564 else 565 return -EINVAL; 566 } 567 568 static int iris_dec_cmd(struct file *filp, void *fh, 569 struct v4l2_decoder_cmd *dec) 570 { 571 struct iris_inst *inst = iris_get_inst(filp); 572 int ret = 0; 573 574 mutex_lock(&inst->lock); 575 576 if (dec->cmd != V4L2_DEC_CMD_STOP && dec->cmd != V4L2_DEC_CMD_START) { 577 ret = -EINVAL; 578 goto unlock; 579 } 580 581 if (inst->state == IRIS_INST_DEINIT) 582 goto unlock; 583 584 if (!iris_allow_cmd(inst, dec->cmd)) { 585 ret = -EBUSY; 586 goto unlock; 587 } 588 589 if (dec->cmd == V4L2_DEC_CMD_START) 590 ret = iris_vdec_start_cmd(inst); 591 else if (dec->cmd == V4L2_DEC_CMD_STOP) 592 ret = iris_vdec_stop_cmd(inst); 593 else 594 ret = -EINVAL; 595 596 unlock: 597 mutex_unlock(&inst->lock); 598 599 return ret; 600 } 601 602 static int iris_enc_cmd(struct file *filp, void *fh, 603 struct v4l2_encoder_cmd *enc) 604 { 605 struct iris_inst *inst = iris_get_inst(filp); 606 int ret = 0; 607 608 mutex_lock(&inst->lock); 609 610 if (enc->cmd != V4L2_ENC_CMD_STOP && enc->cmd != V4L2_ENC_CMD_START) { 611 ret = -EINVAL; 612 goto unlock; 613 } 614 615 if (inst->state == IRIS_INST_DEINIT) 616 goto unlock; 617 618 if (!iris_allow_cmd(inst, enc->cmd)) { 619 ret = -EBUSY; 620 goto unlock; 621 } 622 623 if (enc->cmd == V4L2_ENC_CMD_START) 624 ret = iris_venc_start_cmd(inst); 625 else if (enc->cmd == V4L2_ENC_CMD_STOP) 626 ret = iris_venc_stop_cmd(inst); 627 else 628 ret = -EINVAL; 629 630 unlock: 631 mutex_unlock(&inst->lock); 632 633 return ret; 634 } 635 636 static const struct v4l2_file_operations iris_v4l2_file_ops = { 637 .owner = THIS_MODULE, 638 .open = iris_open, 639 .release = iris_close, 640 .unlocked_ioctl = video_ioctl2, 641 .poll = v4l2_m2m_fop_poll, 642 .mmap = v4l2_m2m_fop_mmap, 643 }; 644 645 static const struct vb2_ops iris_vb2_ops = { 646 .buf_init = iris_vb2_buf_init, 647 .queue_setup = iris_vb2_queue_setup, 648 .start_streaming = iris_vb2_start_streaming, 649 .stop_streaming = iris_vb2_stop_streaming, 650 .buf_prepare = iris_vb2_buf_prepare, 651 .buf_out_validate = iris_vb2_buf_out_validate, 652 .buf_queue = iris_vb2_buf_queue, 653 }; 654 655 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_dec = { 656 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 657 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 658 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 659 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 660 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 661 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 662 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 663 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 664 .vidioc_enum_framesizes = iris_enum_framesizes, 665 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 666 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 667 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 668 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 669 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 670 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 671 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 672 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 673 .vidioc_querycap = iris_querycap, 674 .vidioc_g_selection = iris_g_selection, 675 .vidioc_subscribe_event = iris_subscribe_event, 676 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 677 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 678 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 679 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 680 .vidioc_decoder_cmd = iris_dec_cmd, 681 }; 682 683 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = { 684 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 685 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 686 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 687 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 688 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 689 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 690 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 691 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 692 .vidioc_enum_framesizes = iris_enum_framesizes, 693 .vidioc_enum_frameintervals = iris_enum_frameintervals, 694 .vidioc_querycap = iris_querycap, 695 .vidioc_subscribe_event = iris_subscribe_event, 696 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 697 .vidioc_g_selection = iris_g_selection, 698 .vidioc_s_selection = iris_s_selection, 699 .vidioc_s_parm = iris_s_parm, 700 .vidioc_g_parm = iris_g_parm, 701 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 702 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 703 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 704 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 705 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 706 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 707 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 708 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 709 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 710 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 711 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 712 .vidioc_encoder_cmd = iris_enc_cmd, 713 }; 714 715 void iris_init_ops(struct iris_core *core) 716 { 717 core->iris_v4l2_file_ops = &iris_v4l2_file_ops; 718 core->iris_vb2_ops = &iris_vb2_ops; 719 core->iris_v4l2_ioctl_ops_dec = &iris_v4l2_ioctl_ops_dec; 720 core->iris_v4l2_ioctl_ops_enc = &iris_v4l2_ioctl_ops_enc; 721 } 722