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