iris_common.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (c) 2022-2025 Qualcomm Innovation Center, Inc. All rights reserved.
  4 */
  5
  6#include <media/v4l2-mem2mem.h>
  7
  8#include "iris_common.h"
  9#include "iris_ctrls.h"
 10#include "iris_instance.h"
 11#include "iris_power.h"
 12
 13int iris_vb2_buffer_to_driver(struct vb2_buffer *vb2, struct iris_buffer *buf)
 14{
 15	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb2);
 16
 17	buf->type = iris_v4l2_type_to_driver(vb2->type);
 18	buf->index = vb2->index;
 19	buf->fd = vb2->planes[0].m.fd;
 20	buf->buffer_size = vb2->planes[0].length;
 21	buf->data_offset = vb2->planes[0].data_offset;
 22	buf->data_size = vb2->planes[0].bytesused - vb2->planes[0].data_offset;
 23	buf->flags = vbuf->flags;
 24	buf->timestamp = vb2->timestamp;
 25	buf->attr = 0;
 26
 27	return 0;
 28}
 29
 30void iris_set_ts_metadata(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
 31{
 32	u32 mask = V4L2_BUF_FLAG_TIMECODE | V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
 33	struct vb2_buffer *vb = &vbuf->vb2_buf;
 34	u64 ts_us = vb->timestamp;
 35
 36	if (inst->metadata_idx >= ARRAY_SIZE(inst->tss))
 37		inst->metadata_idx = 0;
 38
 39	do_div(ts_us, NSEC_PER_USEC);
 40
 41	inst->tss[inst->metadata_idx].flags = vbuf->flags & mask;
 42	inst->tss[inst->metadata_idx].tc = vbuf->timecode;
 43	inst->tss[inst->metadata_idx].ts_us = ts_us;
 44	inst->tss[inst->metadata_idx].ts_ns = vb->timestamp;
 45
 46	inst->metadata_idx++;
 47}
 48
 49int iris_process_streamon_input(struct iris_inst *inst)
 50{
 51	const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;
 52	enum iris_inst_sub_state set_sub_state = 0;
 53	int ret;
 54
 55	iris_scale_power(inst);
 56
 57	ret = hfi_ops->session_start(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 58	if (ret)
 59		return ret;
 60
 61	if (inst->sub_state & IRIS_INST_SUB_INPUT_PAUSE) {
 62		ret = iris_inst_change_sub_state(inst, IRIS_INST_SUB_INPUT_PAUSE, 0);
 63		if (ret)
 64			return ret;
 65	}
 66
 67	if (inst->domain == DECODER &&
 68	    (inst->sub_state & IRIS_INST_SUB_DRC ||
 69	     inst->sub_state & IRIS_INST_SUB_DRAIN ||
 70	     inst->sub_state & IRIS_INST_SUB_FIRST_IPSC)) {
 71		if (!(inst->sub_state & IRIS_INST_SUB_INPUT_PAUSE)) {
 72			if (hfi_ops->session_pause) {
 73				ret = hfi_ops->session_pause(inst,
 74							     V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 75				if (ret)
 76					return ret;
 77			}
 78			set_sub_state = IRIS_INST_SUB_INPUT_PAUSE;
 79		}
 80	}
 81
 82	ret = iris_inst_state_change_streamon(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 83	if (ret)
 84		return ret;
 85
 86	inst->last_buffer_dequeued = false;
 87
 88	return iris_inst_change_sub_state(inst, 0, set_sub_state);
 89}
 90
 91int iris_process_streamon_output(struct iris_inst *inst)
 92{
 93	const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;
 94	enum iris_inst_sub_state clear_sub_state = 0;
 95	bool drain_active, drc_active, first_ipsc;
 96	int ret = 0;
 97
 98	iris_scale_power(inst);
 99
100	first_ipsc = inst->sub_state & IRIS_INST_SUB_FIRST_IPSC;
101
102	drain_active = inst->sub_state & IRIS_INST_SUB_DRAIN &&
103		inst->sub_state & IRIS_INST_SUB_DRAIN_LAST;
104
105	drc_active = inst->sub_state & IRIS_INST_SUB_DRC &&
106		inst->sub_state & IRIS_INST_SUB_DRC_LAST;
107
108	if (drc_active)
109		clear_sub_state = IRIS_INST_SUB_DRC | IRIS_INST_SUB_DRC_LAST;
110	else if (drain_active)
111		clear_sub_state = IRIS_INST_SUB_DRAIN | IRIS_INST_SUB_DRAIN_LAST;
112
113	/* Input internal buffer reconfiguration required in case of resolution change */
114	if (first_ipsc || drc_active) {
115		ret = iris_alloc_and_queue_input_int_bufs(inst);
116		if (ret)
117			return ret;
118		ret = iris_set_stage(inst, STAGE);
119		if (ret)
120			return ret;
121		ret = iris_set_pipe(inst, PIPE);
122		if (ret)
123			return ret;
124	}
125
126	if (inst->state == IRIS_INST_INPUT_STREAMING &&
127	    inst->sub_state & IRIS_INST_SUB_INPUT_PAUSE) {
128		if (!drain_active)
129			ret = hfi_ops->session_resume_drc(inst,
130							  V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
131		else if (hfi_ops->session_resume_drain)
132			ret = hfi_ops->session_resume_drain(inst,
133							    V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
134		if (ret)
135			return ret;
136		clear_sub_state |= IRIS_INST_SUB_INPUT_PAUSE;
137	}
138
139	if (inst->sub_state & IRIS_INST_SUB_FIRST_IPSC)
140		clear_sub_state |= IRIS_INST_SUB_FIRST_IPSC;
141
142	ret = hfi_ops->session_start(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
143	if (ret)
144		return ret;
145
146	if (inst->sub_state & IRIS_INST_SUB_OUTPUT_PAUSE)
147		clear_sub_state |= IRIS_INST_SUB_OUTPUT_PAUSE;
148
149	ret = iris_inst_state_change_streamon(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
150	if (ret)
151		return ret;
152
153	inst->last_buffer_dequeued = false;
154
155	return iris_inst_change_sub_state(inst, clear_sub_state, 0);
156}
157
158static void iris_flush_deferred_buffers(struct iris_inst *inst,
159					enum iris_buffer_type type)
160{
161	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
162	struct v4l2_m2m_buffer *buffer, *n;
163	struct iris_buffer *buf;
164
165	if (type == BUF_INPUT) {
166		v4l2_m2m_for_each_src_buf_safe(m2m_ctx, buffer, n) {
167			buf = to_iris_buffer(&buffer->vb);
168			if (buf->attr & BUF_ATTR_DEFERRED) {
169				if (!(buf->attr & BUF_ATTR_BUFFER_DONE)) {
170					buf->attr |= BUF_ATTR_BUFFER_DONE;
171					buf->data_size = 0;
172					iris_vb2_buffer_done(inst, buf);
173				}
174			}
175		}
176	} else {
177		v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, buffer, n) {
178			buf = to_iris_buffer(&buffer->vb);
179			if (buf->attr & BUF_ATTR_DEFERRED) {
180				if (!(buf->attr & BUF_ATTR_BUFFER_DONE)) {
181					buf->attr |= BUF_ATTR_BUFFER_DONE;
182					buf->data_size = 0;
183					iris_vb2_buffer_done(inst, buf);
184				}
185			}
186		}
187	}
188}
189
190static void iris_kill_session(struct iris_inst *inst)
191{
192	const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;
193
194	if (!inst->session_id)
195		return;
196
197	hfi_ops->session_close(inst);
198	iris_inst_change_state(inst, IRIS_INST_ERROR);
199}
200
201int iris_session_streamoff(struct iris_inst *inst, u32 plane)
202{
203	const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;
204	enum iris_buffer_type buffer_type;
205	int ret;
206
207	switch (plane) {
208	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
209		buffer_type = BUF_INPUT;
210		break;
211	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
212		buffer_type = BUF_OUTPUT;
213		break;
214	default:
215		return -EINVAL;
216	}
217
218	ret = hfi_ops->session_stop(inst, plane);
219	if (ret)
220		goto error;
221
222	ret = iris_inst_state_change_streamoff(inst, plane);
223	if (ret)
224		goto error;
225
226	iris_flush_deferred_buffers(inst, buffer_type);
227
228	return 0;
229
230error:
231	iris_kill_session(inst);
232	iris_flush_deferred_buffers(inst, buffer_type);
233
234	return ret;
235}