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_completion(&inst->completion); 182 init_completion(&inst->flush_completion); 183 184 iris_v4l2_fh_init(inst, filp); 185 186 inst->m2m_dev = v4l2_m2m_init(&iris_m2m_ops); 187 if (IS_ERR_OR_NULL(inst->m2m_dev)) { 188 ret = -EINVAL; 189 goto fail_v4l2_fh_deinit; 190 } 191 192 inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, iris_m2m_queue_init); 193 if (IS_ERR_OR_NULL(inst->m2m_ctx)) { 194 ret = -EINVAL; 195 goto fail_m2m_release; 196 } 197 198 if (inst->domain == DECODER) 199 ret = iris_vdec_inst_init(inst); 200 else if (inst->domain == ENCODER) 201 ret = iris_venc_inst_init(inst); 202 if (ret) 203 goto fail_m2m_ctx_release; 204 205 iris_add_session(inst); 206 207 inst->fh.m2m_ctx = inst->m2m_ctx; 208 209 return 0; 210 211 fail_m2m_ctx_release: 212 v4l2_m2m_ctx_release(inst->m2m_ctx); 213 fail_m2m_release: 214 v4l2_m2m_release(inst->m2m_dev); 215 fail_v4l2_fh_deinit: 216 iris_v4l2_fh_deinit(inst, filp); 217 mutex_destroy(&inst->ctx_q_lock); 218 mutex_destroy(&inst->lock); 219 kfree(inst); 220 221 return ret; 222 } 223 224 static void iris_session_close(struct iris_inst *inst) 225 { 226 const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops; 227 bool wait_for_response = true; 228 int ret; 229 230 if (inst->state == IRIS_INST_DEINIT) 231 return; 232 233 reinit_completion(&inst->completion); 234 235 ret = hfi_ops->session_close(inst); 236 if (ret) 237 wait_for_response = false; 238 239 if (wait_for_response) 240 iris_wait_for_session_response(inst, false); 241 } 242 243 static void iris_check_num_queued_internal_buffers(struct iris_inst *inst, u32 plane) 244 { 245 const struct iris_platform_data *platform_data = inst->core->iris_platform_data; 246 struct iris_buffer *buf, *next; 247 struct iris_buffers *buffers; 248 const u32 *internal_buf_type; 249 u32 internal_buffer_count, i; 250 u32 count = 0; 251 252 if (V4L2_TYPE_IS_OUTPUT(plane)) { 253 internal_buf_type = platform_data->dec_ip_int_buf_tbl; 254 internal_buffer_count = platform_data->dec_ip_int_buf_tbl_size; 255 } else { 256 internal_buf_type = platform_data->dec_op_int_buf_tbl; 257 internal_buffer_count = platform_data->dec_op_int_buf_tbl_size; 258 } 259 260 for (i = 0; i < internal_buffer_count; i++) { 261 buffers = &inst->buffers[internal_buf_type[i]]; 262 count = 0; 263 list_for_each_entry_safe(buf, next, &buffers->list, list) 264 count++; 265 if (count) 266 dev_err(inst->core->dev, "%d buffer of type %d not released", 267 count, internal_buf_type[i]); 268 } 269 270 if (inst->domain == DECODER) 271 buffers = &inst->buffers[BUF_PERSIST]; 272 else 273 buffers = &inst->buffers[BUF_ARP]; 274 275 count = 0; 276 list_for_each_entry_safe(buf, next, &buffers->list, list) 277 count++; 278 if (count) 279 dev_err(inst->core->dev, "%d buffer of type %d not released", 280 count, inst->domain == DECODER ? BUF_PERSIST : BUF_ARP); 281 } 282 283 int iris_close(struct file *filp) 284 { 285 struct iris_inst *inst = iris_get_inst(filp); 286 287 v4l2_ctrl_handler_free(&inst->ctrl_handler); 288 v4l2_m2m_ctx_release(inst->m2m_ctx); 289 v4l2_m2m_release(inst->m2m_dev); 290 mutex_lock(&inst->lock); 291 if (inst->domain == DECODER) 292 iris_vdec_inst_deinit(inst); 293 else if (inst->domain == ENCODER) 294 iris_venc_inst_deinit(inst); 295 iris_session_close(inst); 296 iris_inst_change_state(inst, IRIS_INST_DEINIT); 297 iris_v4l2_fh_deinit(inst, filp); 298 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 299 iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 300 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 301 iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 302 iris_remove_session(inst); 303 mutex_unlock(&inst->lock); 304 mutex_destroy(&inst->ctx_q_lock); 305 mutex_destroy(&inst->lock); 306 kfree(inst); 307 308 return 0; 309 } 310 311 static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f) 312 { 313 struct iris_inst *inst = iris_get_inst(filp); 314 315 if (inst->domain == DECODER) 316 return iris_vdec_enum_fmt(inst, f); 317 else if (inst->domain == ENCODER) 318 return iris_venc_enum_fmt(inst, f); 319 else 320 return -EINVAL; 321 } 322 323 static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 324 { 325 struct iris_inst *inst = iris_get_inst(filp); 326 int ret = 0; 327 328 mutex_lock(&inst->lock); 329 330 if (inst->domain == DECODER) 331 ret = iris_vdec_try_fmt(inst, f); 332 else if (inst->domain == ENCODER) 333 ret = iris_venc_try_fmt(inst, f); 334 335 mutex_unlock(&inst->lock); 336 337 return ret; 338 } 339 340 static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 341 { 342 struct iris_inst *inst = iris_get_inst(filp); 343 int ret = 0; 344 345 mutex_lock(&inst->lock); 346 347 if (inst->domain == DECODER) 348 ret = iris_vdec_s_fmt(inst, f); 349 else if (inst->domain == ENCODER) 350 ret = iris_venc_s_fmt(inst, f); 351 352 mutex_unlock(&inst->lock); 353 354 return ret; 355 } 356 357 static int iris_g_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) 358 { 359 struct iris_inst *inst = iris_get_inst(filp); 360 int ret = 0; 361 362 mutex_lock(&inst->lock); 363 if (V4L2_TYPE_IS_OUTPUT(f->type)) 364 *f = *inst->fmt_src; 365 else if (V4L2_TYPE_IS_CAPTURE(f->type)) 366 *f = *inst->fmt_dst; 367 else 368 ret = -EINVAL; 369 370 mutex_unlock(&inst->lock); 371 372 return ret; 373 } 374 375 static int iris_enum_framesizes(struct file *filp, void *fh, 376 struct v4l2_frmsizeenum *fsize) 377 { 378 struct iris_inst *inst = iris_get_inst(filp); 379 struct platform_inst_caps *caps; 380 int ret = 0; 381 382 if (fsize->index) 383 return -EINVAL; 384 385 if (inst->domain == DECODER) 386 ret = iris_vdec_validate_format(inst, fsize->pixel_format); 387 else 388 ret = iris_venc_validate_format(inst, fsize->pixel_format); 389 390 if (ret) 391 return ret; 392 393 caps = inst->core->iris_platform_data->inst_caps; 394 395 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 396 fsize->stepwise.min_width = caps->min_frame_width; 397 fsize->stepwise.max_width = caps->max_frame_width; 398 fsize->stepwise.step_width = STEP_WIDTH; 399 fsize->stepwise.min_height = caps->min_frame_height; 400 fsize->stepwise.max_height = caps->max_frame_height; 401 fsize->stepwise.step_height = STEP_HEIGHT; 402 403 return ret; 404 } 405 406 static int iris_enum_frameintervals(struct file *filp, void *fh, 407 struct v4l2_frmivalenum *fival) 408 409 { 410 struct iris_inst *inst = iris_get_inst(filp); 411 struct iris_core *core = inst->core; 412 struct platform_inst_caps *caps; 413 u32 fps, mbpf; 414 int ret = 0; 415 416 if (inst->domain == DECODER) 417 return -ENOTTY; 418 419 if (fival->index) 420 return -EINVAL; 421 422 ret = iris_venc_validate_format(inst, fival->pixel_format); 423 if (ret) 424 return ret; 425 426 if (!fival->width || !fival->height) 427 return -EINVAL; 428 429 caps = inst->core->iris_platform_data->inst_caps; 430 if (fival->width > caps->max_frame_width || 431 fival->width < caps->min_frame_width || 432 fival->height > caps->max_frame_height || 433 fival->height < caps->min_frame_height) 434 return -EINVAL; 435 436 mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width); 437 fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf); 438 439 fival->type = V4L2_FRMIVAL_TYPE_STEPWISE; 440 fival->stepwise.min.numerator = 1; 441 fival->stepwise.min.denominator = 442 min_t(u32, fps, MAXIMUM_FPS); 443 fival->stepwise.max.numerator = 1; 444 fival->stepwise.max.denominator = 1; 445 fival->stepwise.step.numerator = 1; 446 fival->stepwise.step.denominator = MAXIMUM_FPS; 447 448 return 0; 449 } 450 451 static int iris_querycap(struct file *filp, void *fh, struct v4l2_capability *cap) 452 { 453 struct iris_inst *inst = iris_get_inst(filp); 454 455 strscpy(cap->driver, IRIS_DRV_NAME, sizeof(cap->driver)); 456 457 if (inst->domain == DECODER) 458 strscpy(cap->card, "Iris Decoder", sizeof(cap->card)); 459 else 460 strscpy(cap->card, "Iris Encoder", sizeof(cap->card)); 461 462 return 0; 463 } 464 465 static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s) 466 { 467 struct iris_inst *inst = iris_get_inst(filp); 468 469 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 470 inst->domain == DECODER) 471 return -EINVAL; 472 473 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 474 inst->domain == ENCODER) 475 return -EINVAL; 476 477 if (inst->domain == DECODER) { 478 switch (s->target) { 479 case V4L2_SEL_TGT_CROP_BOUNDS: 480 case V4L2_SEL_TGT_CROP_DEFAULT: 481 case V4L2_SEL_TGT_CROP: 482 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 483 case V4L2_SEL_TGT_COMPOSE_PADDED: 484 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 485 case V4L2_SEL_TGT_COMPOSE: 486 s->r.left = inst->crop.left; 487 s->r.top = inst->crop.top; 488 s->r.width = inst->crop.width; 489 s->r.height = inst->crop.height; 490 break; 491 default: 492 return -EINVAL; 493 } 494 } else if (inst->domain == ENCODER) { 495 switch (s->target) { 496 case V4L2_SEL_TGT_CROP_BOUNDS: 497 case V4L2_SEL_TGT_CROP_DEFAULT: 498 s->r.width = inst->fmt_src->fmt.pix_mp.width; 499 s->r.height = inst->fmt_src->fmt.pix_mp.height; 500 break; 501 case V4L2_SEL_TGT_CROP: 502 s->r.width = inst->crop.width; 503 s->r.height = inst->crop.height; 504 break; 505 default: 506 return -EINVAL; 507 } 508 s->r.left = inst->crop.left; 509 s->r.top = inst->crop.top; 510 } 511 512 return 0; 513 } 514 515 static int iris_s_selection(struct file *filp, void *fh, struct v4l2_selection *s) 516 { 517 struct iris_inst *inst = iris_get_inst(filp); 518 519 if (inst->domain == DECODER) 520 return -EINVAL; 521 else if (inst->domain == ENCODER) 522 return iris_venc_s_selection(inst, s); 523 524 return -EINVAL; 525 } 526 527 static int iris_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) 528 { 529 struct iris_inst *inst = container_of(fh, struct iris_inst, fh); 530 531 if (inst->domain == DECODER) 532 return iris_vdec_subscribe_event(inst, sub); 533 else if (inst->domain == ENCODER) 534 return iris_venc_subscribe_event(inst, sub); 535 536 return -EINVAL; 537 } 538 539 static int iris_s_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 540 { 541 struct iris_inst *inst = iris_get_inst(filp); 542 543 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 544 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 545 return -EINVAL; 546 547 if (inst->domain == ENCODER) 548 return iris_venc_s_param(inst, a); 549 else 550 return -EINVAL; 551 } 552 553 static int iris_g_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) 554 { 555 struct iris_inst *inst = iris_get_inst(filp); 556 557 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && 558 a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 559 return -EINVAL; 560 561 if (inst->domain == ENCODER) 562 return iris_venc_g_param(inst, a); 563 else 564 return -EINVAL; 565 } 566 567 static int iris_dec_cmd(struct file *filp, void *fh, 568 struct v4l2_decoder_cmd *dec) 569 { 570 struct iris_inst *inst = iris_get_inst(filp); 571 int ret = 0; 572 573 mutex_lock(&inst->lock); 574 575 ret = v4l2_m2m_ioctl_decoder_cmd(filp, fh, dec); 576 if (ret) 577 goto unlock; 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 ret = v4l2_m2m_ioctl_encoder_cmd(filp, fh, enc); 609 if (ret) 610 goto unlock; 611 612 if (inst->state == IRIS_INST_DEINIT) 613 goto unlock; 614 615 if (!iris_allow_cmd(inst, enc->cmd)) { 616 ret = -EBUSY; 617 goto unlock; 618 } 619 620 if (enc->cmd == V4L2_ENC_CMD_START) 621 ret = iris_venc_start_cmd(inst); 622 else if (enc->cmd == V4L2_ENC_CMD_STOP) 623 ret = iris_venc_stop_cmd(inst); 624 else 625 ret = -EINVAL; 626 627 unlock: 628 mutex_unlock(&inst->lock); 629 630 return ret; 631 } 632 633 static struct v4l2_file_operations iris_v4l2_file_ops = { 634 .owner = THIS_MODULE, 635 .open = iris_open, 636 .release = iris_close, 637 .unlocked_ioctl = video_ioctl2, 638 .poll = v4l2_m2m_fop_poll, 639 .mmap = v4l2_m2m_fop_mmap, 640 }; 641 642 static const struct vb2_ops iris_vb2_ops = { 643 .buf_init = iris_vb2_buf_init, 644 .queue_setup = iris_vb2_queue_setup, 645 .start_streaming = iris_vb2_start_streaming, 646 .stop_streaming = iris_vb2_stop_streaming, 647 .buf_prepare = iris_vb2_buf_prepare, 648 .buf_out_validate = iris_vb2_buf_out_validate, 649 .buf_queue = iris_vb2_buf_queue, 650 }; 651 652 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_dec = { 653 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 654 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 655 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 656 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 657 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 658 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 659 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 660 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 661 .vidioc_enum_framesizes = iris_enum_framesizes, 662 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 663 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 664 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 665 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 666 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 667 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 668 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 669 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 670 .vidioc_querycap = iris_querycap, 671 .vidioc_g_selection = iris_g_selection, 672 .vidioc_subscribe_event = iris_subscribe_event, 673 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 674 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 675 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 676 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 677 .vidioc_decoder_cmd = iris_dec_cmd, 678 }; 679 680 static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = { 681 .vidioc_enum_fmt_vid_cap = iris_enum_fmt, 682 .vidioc_enum_fmt_vid_out = iris_enum_fmt, 683 .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, 684 .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, 685 .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, 686 .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, 687 .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, 688 .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, 689 .vidioc_enum_framesizes = iris_enum_framesizes, 690 .vidioc_enum_frameintervals = iris_enum_frameintervals, 691 .vidioc_querycap = iris_querycap, 692 .vidioc_subscribe_event = iris_subscribe_event, 693 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 694 .vidioc_g_selection = iris_g_selection, 695 .vidioc_s_selection = iris_s_selection, 696 .vidioc_s_parm = iris_s_parm, 697 .vidioc_g_parm = iris_g_parm, 698 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 699 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 700 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 701 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 702 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 703 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 704 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 705 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 706 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 707 .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, 708 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 709 .vidioc_encoder_cmd = iris_enc_cmd, 710 }; 711 712 void iris_init_ops(struct iris_core *core) 713 { 714 core->iris_v4l2_file_ops = &iris_v4l2_file_ops; 715 core->iris_vb2_ops = &iris_vb2_ops; 716 core->iris_v4l2_ioctl_ops_dec = &iris_v4l2_ioctl_ops_dec; 717 core->iris_v4l2_ioctl_ops_enc = &iris_v4l2_ioctl_ops_enc; 718 } 719