| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. | |
| */ | |
| #include <linux/pm_runtime.h> | |
| #include <media/v4l2-event.h> | |
| #include <media/v4l2-ioctl.h> | |
| #include <media/v4l2-mem2mem.h> | |
| #include <media/videobuf2-dma-contig.h> | |
| #include "iris_ctrls.h" | |
| #include "iris_vidc.h" | |
| #include "iris_instance.h" | |
| #include "iris_vdec.h" | |
| #include "iris_venc.h" | |
| #include "iris_vb2.h" | |
| #include "iris_vpu_buffer.h" | |
| #include "iris_platform_common.h" | |
| #define IRIS_DRV_NAME "iris_driver" | |
| #define IRIS_BUS_NAME "platform:iris_icc" | |
| #define STEP_WIDTH 1 | |
| #define STEP_HEIGHT 1 | |
| static void iris_v4l2_fh_init(struct iris_inst *inst, struct file *filp) | |
| { | |
| if (inst->domain == ENCODER) | |
| v4l2_fh_init(&inst->fh, inst->core->vdev_enc); | |
| else if (inst->domain == DECODER) | |
| v4l2_fh_init(&inst->fh, inst->core->vdev_dec); | |
| inst->fh.ctrl_handler = &inst->ctrl_handler; | |
| v4l2_fh_add(&inst->fh, filp); | |
| } | |
| static void iris_v4l2_fh_deinit(struct iris_inst *inst, struct file *filp) | |
| { | |
| v4l2_fh_del(&inst->fh, filp); | |
| inst->fh.ctrl_handler = NULL; | |
| v4l2_fh_exit(&inst->fh); | |
| } | |
| static void iris_add_session(struct iris_inst *inst) | |
| { | |
| struct iris_core *core = inst->core; | |
| struct iris_inst *iter; | |
| u32 count = 0; | |
| mutex_lock(&core->lock); | |
| list_for_each_entry(iter, &core->instances, list) | |
| count++; | |
| if (count < core->iris_platform_data->max_session_count) | |
| list_add_tail(&inst->list, &core->instances); | |
| mutex_unlock(&core->lock); | |
| } | |
| static void iris_remove_session(struct iris_inst *inst) | |
| { | |
| struct iris_core *core = inst->core; | |
| struct iris_inst *iter, *temp; | |
| mutex_lock(&core->lock); | |
| list_for_each_entry_safe(iter, temp, &core->instances, list) { | |
| if (iter->session_id == inst->session_id) { | |
| list_del_init(&iter->list); | |
| break; | |
| } | |
| } | |
| mutex_unlock(&core->lock); | |
| } | |
| static inline struct iris_inst *iris_get_inst(struct file *filp) | |
| { | |
| return container_of(file_to_v4l2_fh(filp), struct iris_inst, fh); | |
| } | |
| static void iris_m2m_device_run(void *priv) | |
| { | |
| } | |
| static void iris_m2m_job_abort(void *priv) | |
| { | |
| struct iris_inst *inst = priv; | |
| struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx; | |
| v4l2_m2m_job_finish(inst->m2m_dev, m2m_ctx); | |
| } | |
| static const struct v4l2_m2m_ops iris_m2m_ops = { | |
| .device_run = iris_m2m_device_run, | |
| .job_abort = iris_m2m_job_abort, | |
| }; | |
| static int | |
| iris_m2m_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq) | |
| { | |
| struct iris_inst *inst = priv; | |
| int ret; | |
| src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; | |
| src_vq->io_modes = VB2_MMAP | VB2_DMABUF; | |
| src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; | |
| src_vq->ops = inst->core->iris_vb2_ops; | |
| src_vq->mem_ops = &vb2_dma_contig_memops; | |
| src_vq->drv_priv = inst; | |
| src_vq->buf_struct_size = sizeof(struct iris_buffer); | |
| src_vq->min_reqbufs_allocation = MIN_BUFFERS; | |
| src_vq->dev = inst->core->dev; | |
| src_vq->lock = &inst->ctx_q_lock; | |
| ret = vb2_queue_init(src_vq); | |
| if (ret) | |
| return ret; | |
| dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; | |
| dst_vq->io_modes = VB2_MMAP | VB2_DMABUF; | |
| dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; | |
| dst_vq->ops = inst->core->iris_vb2_ops; | |
| dst_vq->mem_ops = &vb2_dma_contig_memops; | |
| dst_vq->drv_priv = inst; | |
| dst_vq->buf_struct_size = sizeof(struct iris_buffer); | |
| dst_vq->min_reqbufs_allocation = MIN_BUFFERS; | |
| dst_vq->dev = inst->core->dev; | |
| dst_vq->lock = &inst->ctx_q_lock; | |
| return vb2_queue_init(dst_vq); | |
| } | |
| int iris_open(struct file *filp) | |
| { | |
| struct iris_core *core = video_drvdata(filp); | |
| struct video_device *vdev; | |
| struct iris_inst *inst; | |
| u32 session_type; | |
| int ret; | |
| vdev = video_devdata(filp); | |
| if (strcmp(vdev->name, "qcom-iris-decoder") == 0) | |
| session_type = DECODER; | |
| else if (strcmp(vdev->name, "qcom-iris-encoder") == 0) | |
| session_type = ENCODER; | |
| else | |
| return -EINVAL; | |
| ret = pm_runtime_resume_and_get(core->dev); | |
| if (ret < 0) | |
| return ret; | |
| ret = iris_core_init(core); | |
| if (ret) { | |
| dev_err(core->dev, "core init failed\n"); | |
| pm_runtime_put_sync(core->dev); | |
| return ret; | |
| } | |
| pm_runtime_put_sync(core->dev); | |
| inst = core->hfi_sys_ops->sys_get_instance(); | |
| if (!inst) | |
| return -ENOMEM; | |
| inst->core = core; | |
| inst->domain = session_type; | |
| inst->session_id = hash32_ptr(inst); | |
| inst->state = IRIS_INST_DEINIT; | |
| mutex_init(&inst->lock); | |
| mutex_init(&inst->ctx_q_lock); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_BIN].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_ARP].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_COMV].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_NON_COMV].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_LINE].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_DPB].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_PERSIST].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_1].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_SCRATCH_2].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_VPSS].list); | |
| INIT_LIST_HEAD(&inst->buffers[BUF_PARTIAL].list); | |
| init_completion(&inst->completion); | |
| init_completion(&inst->flush_completion); | |
| iris_v4l2_fh_init(inst, filp); | |
| inst->m2m_dev = v4l2_m2m_init(&iris_m2m_ops); | |
| if (IS_ERR_OR_NULL(inst->m2m_dev)) { | |
| ret = -EINVAL; | |
| goto fail_v4l2_fh_deinit; | |
| } | |
| inst->m2m_ctx = v4l2_m2m_ctx_init(inst->m2m_dev, inst, iris_m2m_queue_init); | |
| if (IS_ERR_OR_NULL(inst->m2m_ctx)) { | |
| ret = -EINVAL; | |
| goto fail_m2m_release; | |
| } | |
| iris_session_init_caps(core); | |
| if (inst->domain == DECODER) | |
| ret = iris_vdec_inst_init(inst); | |
| else if (inst->domain == ENCODER) | |
| ret = iris_venc_inst_init(inst); | |
| if (ret) | |
| goto fail_m2m_ctx_release; | |
| iris_add_session(inst); | |
| inst->fh.m2m_ctx = inst->m2m_ctx; | |
| return 0; | |
| fail_m2m_ctx_release: | |
| v4l2_m2m_ctx_release(inst->m2m_ctx); | |
| fail_m2m_release: | |
| v4l2_m2m_release(inst->m2m_dev); | |
| fail_v4l2_fh_deinit: | |
| iris_v4l2_fh_deinit(inst, filp); | |
| mutex_destroy(&inst->ctx_q_lock); | |
| mutex_destroy(&inst->lock); | |
| kfree(inst); | |
| return ret; | |
| } | |
| static void iris_session_close(struct iris_inst *inst) | |
| { | |
| const struct iris_hfi_session_ops *hfi_ops = inst->hfi_session_ops; | |
| bool wait_for_response = true; | |
| int ret; | |
| if (inst->state == IRIS_INST_DEINIT) | |
| return; | |
| reinit_completion(&inst->completion); | |
| ret = hfi_ops->session_close(inst); | |
| if (ret) | |
| wait_for_response = false; | |
| if (wait_for_response) | |
| iris_wait_for_session_response(inst, false); | |
| } | |
| static void iris_check_num_queued_internal_buffers(struct iris_inst *inst, u32 plane) | |
| { | |
| const struct iris_firmware_data *firmware_data = inst->core->iris_firmware_data; | |
| struct iris_buffer *buf, *next; | |
| struct iris_buffers *buffers; | |
| const u32 *internal_buf_type; | |
| u32 internal_buffer_count, i; | |
| u32 count = 0; | |
| if (V4L2_TYPE_IS_OUTPUT(plane)) { | |
| internal_buf_type = firmware_data->dec_ip_int_buf_tbl; | |
| internal_buffer_count = firmware_data->dec_ip_int_buf_tbl_size; | |
| } else { | |
| internal_buf_type = firmware_data->dec_op_int_buf_tbl; | |
| internal_buffer_count = firmware_data->dec_op_int_buf_tbl_size; | |
| } | |
| for (i = 0; i < internal_buffer_count; i++) { | |
| buffers = &inst->buffers[internal_buf_type[i]]; | |
| count = 0; | |
| list_for_each_entry_safe(buf, next, &buffers->list, list) | |
| count++; | |
| if (count) | |
| dev_err(inst->core->dev, "%d buffer of type %d not released", | |
| count, internal_buf_type[i]); | |
| } | |
| if (inst->domain == DECODER) | |
| buffers = &inst->buffers[BUF_PERSIST]; | |
| else | |
| buffers = &inst->buffers[BUF_ARP]; | |
| count = 0; | |
| list_for_each_entry_safe(buf, next, &buffers->list, list) | |
| count++; | |
| if (count) | |
| dev_err(inst->core->dev, "%d buffer of type %d not released", | |
| count, inst->domain == DECODER ? BUF_PERSIST : BUF_ARP); | |
| } | |
| int iris_close(struct file *filp) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| v4l2_ctrl_handler_free(&inst->ctrl_handler); | |
| v4l2_m2m_ctx_release(inst->m2m_ctx); | |
| v4l2_m2m_release(inst->m2m_dev); | |
| mutex_lock(&inst->lock); | |
| iris_session_close(inst); | |
| iris_inst_change_state(inst, IRIS_INST_DEINIT); | |
| iris_v4l2_fh_deinit(inst, filp); | |
| iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); | |
| iris_destroy_all_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); | |
| iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); | |
| iris_check_num_queued_internal_buffers(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); | |
| iris_remove_session(inst); | |
| mutex_unlock(&inst->lock); | |
| mutex_destroy(&inst->ctx_q_lock); | |
| mutex_destroy(&inst->lock); | |
| kfree(inst->fmt_src); | |
| kfree(inst->fmt_dst); | |
| kfree(inst); | |
| return 0; | |
| } | |
| static int iris_enum_fmt(struct file *filp, void *fh, struct v4l2_fmtdesc *f) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| if (inst->domain == DECODER) | |
| return iris_vdec_enum_fmt(inst, f); | |
| else if (inst->domain == ENCODER) | |
| return iris_venc_enum_fmt(inst, f); | |
| else | |
| return -EINVAL; | |
| } | |
| static int iris_try_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| int ret = 0; | |
| mutex_lock(&inst->lock); | |
| if (inst->domain == DECODER) | |
| ret = iris_vdec_try_fmt(inst, f); | |
| else if (inst->domain == ENCODER) | |
| ret = iris_venc_try_fmt(inst, f); | |
| mutex_unlock(&inst->lock); | |
| return ret; | |
| } | |
| static int iris_s_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| int ret = 0; | |
| mutex_lock(&inst->lock); | |
| if (inst->domain == DECODER) | |
| ret = iris_vdec_s_fmt(inst, f); | |
| else if (inst->domain == ENCODER) | |
| ret = iris_venc_s_fmt(inst, f); | |
| mutex_unlock(&inst->lock); | |
| return ret; | |
| } | |
| static int iris_g_fmt_vid_mplane(struct file *filp, void *fh, struct v4l2_format *f) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| int ret = 0; | |
| mutex_lock(&inst->lock); | |
| if (V4L2_TYPE_IS_OUTPUT(f->type)) | |
| *f = *inst->fmt_src; | |
| else if (V4L2_TYPE_IS_CAPTURE(f->type)) | |
| *f = *inst->fmt_dst; | |
| else | |
| ret = -EINVAL; | |
| mutex_unlock(&inst->lock); | |
| return ret; | |
| } | |
| static int iris_enum_framesizes(struct file *filp, void *fh, | |
| struct v4l2_frmsizeenum *fsize) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| struct platform_inst_caps *caps; | |
| int ret = 0; | |
| if (fsize->index) | |
| return -EINVAL; | |
| if (inst->domain == DECODER) | |
| ret = iris_vdec_validate_format(inst, fsize->pixel_format); | |
| else | |
| ret = iris_venc_validate_format(inst, fsize->pixel_format); | |
| if (ret) | |
| return ret; | |
| caps = inst->core->iris_platform_data->inst_caps; | |
| fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; | |
| fsize->stepwise.min_width = caps->min_frame_width; | |
| fsize->stepwise.max_width = caps->max_frame_width; | |
| fsize->stepwise.step_width = STEP_WIDTH; | |
| fsize->stepwise.min_height = caps->min_frame_height; | |
| fsize->stepwise.max_height = caps->max_frame_height; | |
| fsize->stepwise.step_height = STEP_HEIGHT; | |
| return ret; | |
| } | |
| static int iris_enum_frameintervals(struct file *filp, void *fh, | |
| struct v4l2_frmivalenum *fival) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| struct iris_core *core = inst->core; | |
| struct platform_inst_caps *caps; | |
| u32 fps, mbpf; | |
| int ret = 0; | |
| if (inst->domain == DECODER) | |
| return -ENOTTY; | |
| if (fival->index) | |
| return -EINVAL; | |
| ret = iris_venc_validate_format(inst, fival->pixel_format); | |
| if (ret) | |
| return ret; | |
| if (!fival->width || !fival->height) | |
| return -EINVAL; | |
| caps = inst->core->iris_platform_data->inst_caps; | |
| if (fival->width > caps->max_frame_width || | |
| fival->width < caps->min_frame_width || | |
| fival->height > caps->max_frame_height || | |
| fival->height < caps->min_frame_height) | |
| return -EINVAL; | |
| mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width); | |
| fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf); | |
| fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS; | |
| fival->stepwise.min.numerator = 1; | |
| fival->stepwise.min.denominator = | |
| min_t(u32, fps, MAXIMUM_FPS); | |
| fival->stepwise.max.numerator = 1; | |
| fival->stepwise.max.denominator = 1; | |
| fival->stepwise.step.numerator = 1; | |
| fival->stepwise.step.denominator = 1; | |
| return 0; | |
| } | |
| static int iris_querycap(struct file *filp, void *fh, struct v4l2_capability *cap) | |
| { | |
| struct iris_core *core = video_drvdata(filp); | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| char *info; | |
| strscpy(cap->driver, IRIS_DRV_NAME, sizeof(cap->driver)); | |
| if (inst->domain == DECODER) { | |
| strscpy(cap->card, "Iris Decoder", sizeof(cap->card)); | |
| info = "dec"; | |
| } else { | |
| strscpy(cap->card, "Iris Encoder", sizeof(cap->card)); | |
| info = "enc"; | |
| } | |
| snprintf(cap->bus_info, sizeof(cap->bus_info), | |
| "platform:%s:%s", dev_name(core->dev), info); | |
| return 0; | |
| } | |
| static int iris_g_selection(struct file *filp, void *fh, struct v4l2_selection *s) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && | |
| inst->domain == DECODER) | |
| return -EINVAL; | |
| if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && | |
| inst->domain == ENCODER) | |
| return -EINVAL; | |
| if (inst->domain == DECODER) { | |
| switch (s->target) { | |
| case V4L2_SEL_TGT_CROP_BOUNDS: | |
| case V4L2_SEL_TGT_CROP_DEFAULT: | |
| case V4L2_SEL_TGT_CROP: | |
| case V4L2_SEL_TGT_COMPOSE_BOUNDS: | |
| case V4L2_SEL_TGT_COMPOSE_PADDED: | |
| case V4L2_SEL_TGT_COMPOSE_DEFAULT: | |
| case V4L2_SEL_TGT_COMPOSE: | |
| s->r.left = inst->crop.left; | |
| s->r.top = inst->crop.top; | |
| s->r.width = inst->crop.width; | |
| s->r.height = inst->crop.height; | |
| break; | |
| default: | |
| return -EINVAL; | |
| } | |
| } else if (inst->domain == ENCODER) { | |
| switch (s->target) { | |
| case V4L2_SEL_TGT_CROP_BOUNDS: | |
| case V4L2_SEL_TGT_CROP_DEFAULT: | |
| s->r.width = inst->fmt_src->fmt.pix_mp.width; | |
| s->r.height = inst->fmt_src->fmt.pix_mp.height; | |
| break; | |
| case V4L2_SEL_TGT_CROP: | |
| s->r.width = inst->crop.width; | |
| s->r.height = inst->crop.height; | |
| break; | |
| default: | |
| return -EINVAL; | |
| } | |
| s->r.left = inst->crop.left; | |
| s->r.top = inst->crop.top; | |
| } | |
| return 0; | |
| } | |
| static int iris_s_selection(struct file *filp, void *fh, struct v4l2_selection *s) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| if (inst->domain == DECODER) | |
| return -EINVAL; | |
| else if (inst->domain == ENCODER) | |
| return iris_venc_s_selection(inst, s); | |
| return -EINVAL; | |
| } | |
| static int iris_subscribe_event(struct v4l2_fh *fh, const struct v4l2_event_subscription *sub) | |
| { | |
| struct iris_inst *inst = container_of(fh, struct iris_inst, fh); | |
| if (inst->domain == DECODER) | |
| return iris_vdec_subscribe_event(inst, sub); | |
| else if (inst->domain == ENCODER) | |
| return iris_venc_subscribe_event(inst, sub); | |
| return -EINVAL; | |
| } | |
| static int iris_s_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && | |
| a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) | |
| return -EINVAL; | |
| if (inst->domain == ENCODER) | |
| return iris_venc_s_param(inst, a); | |
| else | |
| return -EINVAL; | |
| } | |
| static int iris_g_parm(struct file *filp, void *fh, struct v4l2_streamparm *a) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && | |
| a->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) | |
| return -EINVAL; | |
| if (inst->domain == ENCODER) | |
| return iris_venc_g_param(inst, a); | |
| else | |
| return -EINVAL; | |
| } | |
| static int iris_dec_cmd(struct file *filp, void *fh, | |
| struct v4l2_decoder_cmd *dec) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| int ret = 0; | |
| mutex_lock(&inst->lock); | |
| if (dec->cmd != V4L2_DEC_CMD_STOP && dec->cmd != V4L2_DEC_CMD_START) { | |
| ret = -EINVAL; | |
| goto unlock; | |
| } | |
| if (inst->state == IRIS_INST_DEINIT) | |
| goto unlock; | |
| if (!iris_allow_cmd(inst, dec->cmd)) { | |
| ret = -EBUSY; | |
| goto unlock; | |
| } | |
| if (dec->cmd == V4L2_DEC_CMD_START) | |
| ret = iris_vdec_start_cmd(inst); | |
| else if (dec->cmd == V4L2_DEC_CMD_STOP) | |
| ret = iris_vdec_stop_cmd(inst); | |
| else | |
| ret = -EINVAL; | |
| unlock: | |
| mutex_unlock(&inst->lock); | |
| return ret; | |
| } | |
| static int iris_enc_cmd(struct file *filp, void *fh, | |
| struct v4l2_encoder_cmd *enc) | |
| { | |
| struct iris_inst *inst = iris_get_inst(filp); | |
| int ret = 0; | |
| mutex_lock(&inst->lock); | |
| if (enc->cmd != V4L2_ENC_CMD_STOP && enc->cmd != V4L2_ENC_CMD_START) { | |
| ret = -EINVAL; | |
| goto unlock; | |
| } | |
| if (inst->state == IRIS_INST_DEINIT) | |
| goto unlock; | |
| if (!iris_allow_cmd(inst, enc->cmd)) { | |
| ret = -EBUSY; | |
| goto unlock; | |
| } | |
| if (enc->cmd == V4L2_ENC_CMD_START) | |
| ret = iris_venc_start_cmd(inst); | |
| else if (enc->cmd == V4L2_ENC_CMD_STOP) | |
| ret = iris_venc_stop_cmd(inst); | |
| else | |
| ret = -EINVAL; | |
| unlock: | |
| mutex_unlock(&inst->lock); | |
| return ret; | |
| } | |
| static const struct v4l2_file_operations iris_v4l2_file_ops = { | |
| .owner = THIS_MODULE, | |
| .open = iris_open, | |
| .release = iris_close, | |
| .unlocked_ioctl = video_ioctl2, | |
| .poll = v4l2_m2m_fop_poll, | |
| .mmap = v4l2_m2m_fop_mmap, | |
| }; | |
| static const struct vb2_ops iris_vb2_ops = { | |
| .buf_init = iris_vb2_buf_init, | |
| .queue_setup = iris_vb2_queue_setup, | |
| .start_streaming = iris_vb2_start_streaming, | |
| .stop_streaming = iris_vb2_stop_streaming, | |
| .buf_prepare = iris_vb2_buf_prepare, | |
| .buf_out_validate = iris_vb2_buf_out_validate, | |
| .buf_queue = iris_vb2_buf_queue, | |
| }; | |
| static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_dec = { | |
| .vidioc_enum_fmt_vid_cap = iris_enum_fmt, | |
| .vidioc_enum_fmt_vid_out = iris_enum_fmt, | |
| .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, | |
| .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, | |
| .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, | |
| .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, | |
| .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, | |
| .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, | |
| .vidioc_enum_framesizes = iris_enum_framesizes, | |
| .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, | |
| .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, | |
| .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, | |
| .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, | |
| .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, | |
| .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, | |
| .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, | |
| .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, | |
| .vidioc_querycap = iris_querycap, | |
| .vidioc_g_selection = iris_g_selection, | |
| .vidioc_subscribe_event = iris_subscribe_event, | |
| .vidioc_unsubscribe_event = v4l2_event_unsubscribe, | |
| .vidioc_streamon = v4l2_m2m_ioctl_streamon, | |
| .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, | |
| .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, | |
| .vidioc_decoder_cmd = iris_dec_cmd, | |
| }; | |
| static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = { | |
| .vidioc_enum_fmt_vid_cap = iris_enum_fmt, | |
| .vidioc_enum_fmt_vid_out = iris_enum_fmt, | |
| .vidioc_try_fmt_vid_cap_mplane = iris_try_fmt_vid_mplane, | |
| .vidioc_try_fmt_vid_out_mplane = iris_try_fmt_vid_mplane, | |
| .vidioc_s_fmt_vid_cap_mplane = iris_s_fmt_vid_mplane, | |
| .vidioc_s_fmt_vid_out_mplane = iris_s_fmt_vid_mplane, | |
| .vidioc_g_fmt_vid_cap_mplane = iris_g_fmt_vid_mplane, | |
| .vidioc_g_fmt_vid_out_mplane = iris_g_fmt_vid_mplane, | |
| .vidioc_enum_framesizes = iris_enum_framesizes, | |
| .vidioc_enum_frameintervals = iris_enum_frameintervals, | |
| .vidioc_querycap = iris_querycap, | |
| .vidioc_subscribe_event = iris_subscribe_event, | |
| .vidioc_unsubscribe_event = v4l2_event_unsubscribe, | |
| .vidioc_g_selection = iris_g_selection, | |
| .vidioc_s_selection = iris_s_selection, | |
| .vidioc_s_parm = iris_s_parm, | |
| .vidioc_g_parm = iris_g_parm, | |
| .vidioc_streamon = v4l2_m2m_ioctl_streamon, | |
| .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, | |
| .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, | |
| .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, | |
| .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, | |
| .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, | |
| .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, | |
| .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, | |
| .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, | |
| .vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs, | |
| .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, | |
| .vidioc_encoder_cmd = iris_enc_cmd, | |
| }; | |
| void iris_init_ops(struct iris_core *core) | |
| { | |
| core->iris_v4l2_file_ops = &iris_v4l2_file_ops; | |
| core->iris_vb2_ops = &iris_vb2_ops; | |
| core->iris_v4l2_ioctl_ops_dec = &iris_v4l2_ioctl_ops_dec; | |
| core->iris_v4l2_ioctl_ops_enc = &iris_v4l2_ioctl_ops_enc; | |
| } |