mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Charvi Mehta <charvi.mehta@arm.com>
To: linux-media@vger.kernel.org, devicetree@vger.kernel.org,
	linux-kernel@vger.kernel.org
Cc: Charvi Mehta <charvi.mehta@arm.com>,
	Mauro Carvalho Chehab <mchehab@kernel.org>,
	Rob Herring <robh@kernel.org>,
	Krzysztof Kozlowski <krzk+dt@kernel.org>,
	Conor Dooley <conor+dt@kernel.org>,
	Philipp Zabel <p.zabel@pengutronix.de>,
	Vincenzo Frascino <vincenzo.frascino@arm.com>,
	Rathinavel Sankaralingam <rath.sankaralingam@arm.com>,
	Shobhit Pandey <shobhit.pandey@arm.com>
Subject: [RFC PATCH 19/28] media: mali-vpu: start decoder firmware through LSID scheduling
Date: Thu, 19 Nov 2026 15:37:49 +0000	[thread overview]
Message-ID: <20261119153758.1426673-20-charvi.mehta@arm.com> (raw)
In-Reply-To: <20261119153758.1426673-1-charvi.mehta@arm.com>

Connect decoder firmware execution to queue preparation and asynchronous
firmware loading. Start the decoder when OUTPUT requests streaming,
without requiring CAPTURE to be streaming.

Activate the LSID and wait for pending option responses before requesting
the firmware running state. Track requested and confirmed firmware states
and coordinate shutdown with firmware responses and interrupt processing.

Signed-off-by: Charvi Mehta <charvi.mehta@arm.com>
---
 .../platform/arm/mali-vpu/mali-vpu-formats.c  |   7 +
 .../platform/arm/mali-vpu/mali-vpu-formats.h  |   1 +
 .../platform/arm/mali-vpu/mali-vpu-session.c  | 297 +++++++++++++++++-
 .../platform/arm/mali-vpu/mali-vpu-session.h  |  12 +
 .../platform/arm/mali-vpu/mali-vpu-vb2.c      |  46 ++-
 .../platform/arm/mali-vpu/mali-vpu-vidioc.c   |   2 +
 6 files changed, 356 insertions(+), 9 deletions(-)

diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.c
index 57aa1b3baf40f..072e3b4aa9473 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.c
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.c
@@ -20,6 +20,13 @@ bool mali_vpu_is_coded_q(const struct mali_vpu_session *sess, enum v4l2_buf_type
 	return V4L2_TYPE_IS_CAPTURE(type);
 }
 
+bool mali_vpu_is_raw_q(const struct mali_vpu_session *sess, enum v4l2_buf_type type)
+{
+	if (sess->role == MALI_VPU_DECODER)
+		return V4L2_TYPE_IS_CAPTURE(type);
+	return V4L2_TYPE_IS_OUTPUT(type);
+}
+
 const struct mali_vpu_format_desc *
 mali_vpu_find_format(struct mali_vpu_session *sess, u32 pixfmt,
 		     enum v4l2_buf_type type)
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.h
index 37198325ee481..6901e295d7c33 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.h
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-formats.h
@@ -34,5 +34,6 @@ int mali_vpu_fill_pixmp_fmt(const struct mali_vpu_format_desc *fmt,
 			    u32 width, u32 height,
 			    struct v4l2_pix_format_mplane *pix_mp);
 bool mali_vpu_is_coded_q(const struct mali_vpu_session *sess, enum v4l2_buf_type type);
+bool mali_vpu_is_raw_q(const struct mali_vpu_session *sess, enum v4l2_buf_type type);
 
 #endif /* __MALI_VPU_FORMATS_H__ */
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-session.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-session.c
index 09ec6d14f4ad0..6d22a5d479008 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-session.c
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-session.c
@@ -19,8 +19,15 @@
 #include "mali-vpu-variant.h"
 #include "mali-vpu-vb2.h"
 
+static const unsigned int mali_vpu_fw_response_timeout_ms = 10000;
 static const unsigned int mali_vpu_fw_load_timeout_ms     = 10000;
 
+static struct mali_vpu_port *
+mali_vpu_session_get_port(struct mali_vpu_session *sess, enum v4l2_buf_type type)
+{
+	return V4L2_TYPE_IS_OUTPUT(type) ? &sess->port_src : &sess->port_dst;
+}
+
 static int mali_vpu_set_port_fmt(struct mali_vpu_port *port,
 				 enum v4l2_buf_type type,
 				 u32 width, u32 height)
@@ -67,10 +74,91 @@ mali_vpu_both_ports_unrequested(struct mali_vpu_session *sess)
 	       !sess->port_dst.stream_requested;
 }
 
+static bool mali_vpu_session_can_stream(const struct mali_vpu_session *sess)
+{
+	/*
+	 * Start a decoder with OUTPUT/src port only, so firmware can
+	 * parse the bitstream and report its decoded format.
+	 * An encoder requires both ports.
+	 *
+	 * Use the driver's preparation state because VB2 sets its streaming
+	 * flag only after prepare_streaming() and initial buffer handoff.
+	 */
+	if (sess->role == MALI_VPU_DECODER)
+		return sess->port_src.stream_requested;
+
+	return sess->port_src.stream_requested &&
+	       sess->port_dst.stream_requested;
+}
+
+static int mali_vpu_session_fw_send_job(struct mali_vpu_session *sess, u16 frames)
+{
+	int ret;
+
+	ret = mali_vpu_fw_send_job(&sess->fw, sess->ncores, frames);
+	if (ret)
+		return ret;
+
+	mali_vpu_sched_send_irq(&sess->sched_sess, &sess->vpu_dev->sched);
+	return 0;
+}
+
+static int mali_vpu_session_fw_send_ping(struct mali_vpu_session *sess)
+{
+	int ret;
+
+	ret = mali_vpu_fw_send_ping(&sess->fw);
+	if (ret)
+		return ret;
+
+	mali_vpu_sched_send_irq(&sess->sched_sess, &sess->vpu_dev->sched);
+	return 0;
+}
+
+static int mali_vpu_session_fw_send_state(struct mali_vpu_session *sess,
+					  enum mali_vpu_fw_state new_state)
+{
+	int ret;
+
+	if (sess->fw_requested_state != sess->fw_state)
+		/* There is a pending request: is this one duplicate? */
+		return sess->fw_requested_state == new_state ? 0 : -EBUSY;
+
+	if (sess->fw_state == new_state)
+		return 0;
+
+	ret = mali_vpu_fw_send_state_change(&sess->fw, new_state);
+	if (ret)
+		return ret;
+
+	sess->fw_requested_state = new_state;
+	mali_vpu_sched_send_irq(&sess->sched_sess, &sess->vpu_dev->sched);
+
+	return 0;
+}
+
 int mali_vpu_session_fw_send_set_option(struct mali_vpu_session *sess,
 					struct mali_vpu_fw_set_option *opt)
 {
-	return mali_vpu_fw_send_set_option(&sess->fw, opt);
+	int ret;
+
+	ret = mali_vpu_fw_send_set_option(&sess->fw, opt);
+	if (ret)
+		return ret;
+
+	mali_vpu_sched_send_irq(&sess->sched_sess, &sess->vpu_dev->sched);
+	return 0;
+}
+
+static int mali_vpu_session_sched_activate(struct mali_vpu_session *sess)
+{
+	lockdep_assert_held(&sess->vq_lock);
+
+	if (sess->sched_sess.lsid)
+		return 0;
+
+	/* This maps LSID 0 and makes any staged IRQHOST visible. */
+	return mali_vpu_sched_switch_in(&sess->sched_sess, &sess->vpu_dev->sched);
 }
 
 static int mali_vpu_session_handle_fw_msg(struct mali_vpu_session *sess,
@@ -123,6 +211,102 @@ static int mali_vpu_session_handle_fw_msg(struct mali_vpu_session *sess,
 	}
 }
 
+static int mali_vpu_session_wait_pending(struct mali_vpu_session *sess)
+{
+	long timeout;
+
+	lockdep_assert_held(&sess->vq_lock);
+
+	while (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_READY &&
+	       sess->fw.pending_response_count) {
+		mutex_unlock(&sess->vq_lock);
+
+		timeout = wait_event_timeout(sess->fw_waitq,
+					     READ_ONCE(sess->fw_bin_state) !=
+					     MALI_VPU_SESSION_FW_BIN_READY ||
+					     !READ_ONCE(sess->fw.pending_response_count),
+					     msecs_to_jiffies(mali_vpu_fw_response_timeout_ms));
+
+		mutex_lock(&sess->vq_lock);
+
+		if (!timeout && sess->fw.pending_response_count)
+			return -ETIMEDOUT;
+	}
+
+	return 0;
+}
+
+static int mali_vpu_session_fw_init(struct mali_vpu_session *sess)
+{
+	int ret;
+
+	lockdep_assert_held(&sess->vq_lock);
+
+	if (sess->fw_requested_state != sess->fw_state) {
+		if (sess->fw_requested_state != MALI_VPU_FW_STATE_RUNNING)
+			return -EBUSY;
+
+		return mali_vpu_session_sched_activate(sess);
+	}
+
+	if (sess->fw_state == MALI_VPU_FW_STATE_RUNNING)
+		return 0;
+
+	ret = mali_vpu_session_fw_send_job(sess, 0);
+	if (ret)
+		return ret;
+
+	/*
+	 * Map the LSID and allow the stopped firmware to process the
+	 * queued SET_OPTION requests before it can be RUNNING.
+	 */
+	ret = mali_vpu_session_sched_activate(sess);
+	if (ret)
+		return ret;
+
+	ret = mali_vpu_session_fw_send_ping(sess);
+	if (ret)
+		return ret;
+
+	ret = mali_vpu_apply_staged_controls(sess);
+	if (ret)
+		return ret;
+
+	/*
+	 * SET_OPTION is only valid while stopped. Wait for pending option
+	 * responses before requesting RUNNING.
+	 */
+	ret = mali_vpu_session_wait_pending(sess);
+	if (ret)
+		return ret;
+
+	/* Waiting drops vq_lock, so streaming may have been withdrawn. */
+	if (!mali_vpu_session_can_stream(sess))
+		return 0;
+
+	return mali_vpu_session_fw_send_state(sess, MALI_VPU_FW_STATE_RUNNING);
+}
+
+static int mali_vpu_session_fw_stop(struct mali_vpu_session *sess)
+{
+	int ret;
+
+	lockdep_assert_held(&sess->vq_lock);
+
+	ret = mali_vpu_session_wait_pending(sess);
+	if (ret)
+		return ret;
+
+	if (sess->fw_state == MALI_VPU_FW_STATE_STOPPED)
+		return 0;
+
+	ret = mali_vpu_session_fw_send_state(sess, MALI_VPU_FW_STATE_STOPPED);
+	if (ret)
+		return ret;
+
+	return mali_vpu_session_wait_pending(sess);
+}
+
 int mali_vpu_session_init(struct mali_vpu_session *sess)
 {
 	int ret;
@@ -170,7 +354,9 @@ int mali_vpu_session_init(struct mali_vpu_session *sess)
 	sess->port_src.stream_requested = false;
 	sess->port_dst.stream_requested = false;
 	init_completion(&sess->fw_load_done);
+	init_waitqueue_head(&sess->fw_waitq);
 	sess->fw_state = MALI_VPU_FW_STATE_STOPPED;
+	sess->fw_requested_state = MALI_VPU_FW_STATE_STOPPED;
 
 	return 0;
 
@@ -208,6 +394,8 @@ int mali_vpu_session_cleanup(struct mali_vpu_session *sess)
 {
 	struct mali_vpu_dev *vpu_dev = sess->vpu_dev;
 	int fw_load_ret = 0;
+	int fw_stop_ret = 0;
+	int terminate_ret;
 	bool waiter_cancelled = false;
 
 	mutex_lock(&sess->vq_lock);
@@ -215,7 +403,9 @@ int mali_vpu_session_cleanup(struct mali_vpu_session *sess)
 	sess->port_src.stream_requested = false;
 	sess->port_dst.stream_requested = false;
 
-	if (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_LOADING) {
+	if (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_LOADING ||
+	    (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_READY &&
+	     !completion_done(&sess->fw_load_done))) {
 		mutex_unlock(&sess->vq_lock);
 
 		if (!wait_for_completion_timeout(&sess->fw_load_done,
@@ -243,6 +433,21 @@ int mali_vpu_session_cleanup(struct mali_vpu_session *sess)
 			sess->fw_bin_state = MALI_VPU_SESSION_FW_BIN_FAILED;
 	}
 
+	if (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_READY)
+		fw_stop_ret = mali_vpu_session_fw_stop(sess);
+
+	terminate_ret = mali_vpu_sched_session_terminate(&sess->sched_sess,
+							 &vpu_dev->sched);
+	mutex_unlock(&sess->vq_lock);
+
+	/*
+	 * The LSID is no longer routed to this session. Drain a worker that
+	 * may have resolved sess before it was detached.
+	 */
+	flush_work(&vpu_dev->irq_work);
+
+	mutex_lock(&sess->vq_lock);
+
 	mali_vpu_session_release_fw_bin(sess);
 
 	if (sess->m2m_ctx) {
@@ -258,7 +463,72 @@ int mali_vpu_session_cleanup(struct mali_vpu_session *sess)
 	mali_vpu_ctrls_cleanup(sess);
 	mutex_destroy(&sess->vq_lock);
 
-	return fw_load_ret;
+	if (fw_load_ret)
+		return fw_load_ret;
+
+	if (fw_stop_ret)
+		return fw_stop_ret;
+
+	return terminate_ret;
+}
+
+int mali_vpu_session_prepare_streaming(struct mali_vpu_session *sess,
+				       enum v4l2_buf_type type)
+{
+	struct mali_vpu_port *port = mali_vpu_session_get_port(sess, type);
+	int ret;
+
+	lockdep_assert_held(&sess->vq_lock);
+
+	if (port->stream_requested)
+		return 0;
+
+	if (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_READY &&
+	    sess->fw_requested_state != sess->fw_state &&
+	    sess->fw_requested_state != MALI_VPU_FW_STATE_RUNNING)
+		return -EBUSY;
+
+	port->stream_requested = true;
+
+	if (sess->fw_bin_state == MALI_VPU_SESSION_FW_BIN_READY &&
+	    mali_vpu_session_can_stream(sess)) {
+		ret = mali_vpu_session_fw_init(sess);
+		if (ret)
+			goto err_rollback;
+	}
+
+	return 0;
+
+err_rollback:
+	port->stream_requested = false;
+
+	return ret;
+}
+
+int mali_vpu_session_streamoff(struct mali_vpu_session *sess, enum v4l2_buf_type type)
+{
+	struct mali_vpu_port *port = mali_vpu_session_get_port(sess, type);
+	int ret;
+
+	lockdep_assert_held(&sess->vq_lock);
+
+	if (!port->stream_requested)
+		return 0;
+
+	port->stream_requested = false;
+
+	if (sess->fw_bin_state != MALI_VPU_SESSION_FW_BIN_READY ||
+	    !sess->sched_sess.lsid)
+		return 0;
+
+	if (mali_vpu_is_raw_q(sess, type))
+		return mali_vpu_session_wait_pending(sess);
+
+	ret = mali_vpu_session_fw_stop(sess);
+	if (ret)
+		return ret;
+
+	return mali_vpu_session_wait_pending(sess);
 }
 
 static void mali_vpu_session_fw_bin_ready(struct mali_vpu_fw_bin *vpu_fw_bin,
@@ -308,8 +578,27 @@ static void mali_vpu_session_fw_bin_ready(struct mali_vpu_fw_bin *vpu_fw_bin,
 
 	sess->fw_bin_state = MALI_VPU_SESSION_FW_BIN_READY;
 
+	/*
+	 * A synchronous callback leaves startup to session preparation.
+	 * A delayed callback completes startup itself.
+	 */
+	if (!same_thread && mali_vpu_session_can_stream(sess)) {
+		ret = mali_vpu_session_fw_init(sess);
+		if (ret) {
+			dev_err(sess->vpu_dev->dev,
+				"failed to start streaming: %d\n", ret);
+			sess->fw_bin_state = MALI_VPU_SESSION_FW_BIN_UNINITIALIZED;
+			goto err_fw_cleanup;
+		}
+	}
+
 	goto out_complete;
 
+err_fw_cleanup:
+	mali_vpu_fw_cleanup(&sess->fw);
+	sess->fw_state = MALI_VPU_FW_STATE_STOPPED;
+	sess->fw_requested_state = MALI_VPU_FW_STATE_STOPPED;
+
 err_cache_put:
 	mali_vpu_fw_cache_put(vpu_fw_bin);
 
@@ -405,5 +694,7 @@ void mali_vpu_session_irq(struct mali_vpu_session *sess)
 	} while (ret >= 0);
 
 unlock_mutex:
+	wake_up(&sess->fw_waitq);
+
 	mutex_unlock(&sess->vq_lock);
 }
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-session.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-session.h
index e6b9de3b272cf..e331965d32fd8 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-session.h
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-session.h
@@ -47,6 +47,11 @@ struct mali_vpu_port {
  * construct the firmware address space before making the binary READY. The
  * session retains its binary reference until cleanup.
  *
+ * A synchronous callback leaves firmware startup to session preparation.
+ * An asynchronous callback starts firmware if the required ports still request
+ * streaming: OUTPUT for a decoder, both ports for an encoder.
+ * Binary READY and firmware RUNNING are separate states.
+ *
  * Session cleanup waits for an in-flight callback before releasing the
  * session-owned binary reference and callback event. On timeout, it cancels
  * the pending cache waiter or waits for an already claimed callback.
@@ -78,7 +83,9 @@ enum mali_vpu_session_fw_bin_state {
  * @fw_event: Firmware binary load event callback structure for this session.
  * @fw_bin_state: Session firmware binary status.
  * @fw_load_done: Completion used to synchronize teardown with an in-flight firmware load.
+ * @fw_waitq: Wait queue used while waiting for firmware responses.
  * @fw_state: Last state confirmed by the firmware.
+ * @fw_requested_state: Last firmware state requested by the driver.
  * @sched_sess: Scheduler state used to map this session to an LSID.
  * @ncores: Number of cores assigned to this session by scheduler.
  */
@@ -104,7 +111,9 @@ struct mali_vpu_session {
 	struct mali_vpu_fw_event		*fw_event;
 	enum mali_vpu_session_fw_bin_state	fw_bin_state;
 	struct completion			fw_load_done;
+	wait_queue_head_t			fw_waitq;
 	enum mali_vpu_fw_state			fw_state;
+	enum mali_vpu_fw_state			fw_requested_state;
 
 	struct mali_vpu_sched_session	sched_sess;
 	u32				ncores;
@@ -115,6 +124,9 @@ int mali_vpu_session_cleanup(struct mali_vpu_session *sess);
 int mali_vpu_session_request_fw_load(struct mali_vpu_session *sess);
 int mali_vpu_session_fw_send_set_option(struct mali_vpu_session *sess,
 					struct mali_vpu_fw_set_option *opt);
+int mali_vpu_session_prepare_streaming(struct mali_vpu_session *sess,
+				       enum v4l2_buf_type type);
+int mali_vpu_session_streamoff(struct mali_vpu_session *sess, enum v4l2_buf_type type);
 void mali_vpu_session_irq(struct mali_vpu_session *sess);
 
 static inline struct mali_vpu_session *mali_vpu_get_session(struct file *filp)
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-vb2.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-vb2.c
index 4262758a5be26..b9f6968e9f13f 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-vb2.c
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-vb2.c
@@ -62,8 +62,6 @@ static void mali_vpu_vb2_buffer_queue(struct vb2_buffer *vb2_buf)
 static int mali_vpu_vb2_prepare_streaming(struct vb2_queue *q)
 {
 	struct mali_vpu_session *sess = vb2_get_drv_priv(q);
-	struct mali_vpu_port *port = V4L2_TYPE_IS_OUTPUT(q->type) ?
-					&sess->port_src : &sess->port_dst;
 	int ret;
 
 	if (mali_vpu_is_coded_q(sess, q->type)) {
@@ -72,17 +70,51 @@ static int mali_vpu_vb2_prepare_streaming(struct vb2_queue *q)
 			return ret;
 	}
 
-	port->stream_requested = true;
+	return mali_vpu_session_prepare_streaming(sess, q->type);
+}
+
+static int mali_vpu_vb2_start_streaming(struct vb2_queue *q,
+					unsigned int count __always_unused)
+{
+	struct mali_vpu_session *sess = vb2_get_drv_priv(q);
+
+	v4l2_m2m_update_start_streaming_state(sess->m2m_ctx, q);
 	return 0;
 }
 
+static void mali_vpu_vb2_stop_streaming(struct vb2_queue *q)
+{
+	struct mali_vpu_session *sess = vb2_get_drv_priv(q);
+	struct vb2_v4l2_buffer *v4l2_buf;
+	int ret;
+
+	ret = mali_vpu_session_streamoff(sess, q->type);
+	if (ret)
+		dev_warn(sess->vpu_dev->dev, "failed to stop streaming: %d\n", ret);
+
+	if (V4L2_TYPE_IS_OUTPUT(q->type)) {
+		while ((v4l2_buf = v4l2_m2m_src_buf_remove(sess->m2m_ctx)))
+			v4l2_m2m_buf_done(v4l2_buf, VB2_BUF_STATE_ERROR);
+	} else {
+		while ((v4l2_buf = v4l2_m2m_dst_buf_remove(sess->m2m_ctx)))
+			v4l2_m2m_buf_done(v4l2_buf, VB2_BUF_STATE_ERROR);
+	}
+
+	v4l2_m2m_update_stop_streaming_state(sess->m2m_ctx, q);
+}
+
 static void mali_vpu_vb2_unprepare_streaming(struct vb2_queue *q)
 {
 	struct mali_vpu_session *sess = vb2_get_drv_priv(q);
-	struct mali_vpu_port *port = V4L2_TYPE_IS_OUTPUT(q->type) ?
-					&sess->port_src : &sess->port_dst;
+	int ret;
+
+	ret = mali_vpu_session_streamoff(sess, q->type);
+	if (ret)
+		dev_warn(sess->vpu_dev->dev,
+			 "failed to unprepare streaming: %d\n", ret);
 
-	port->stream_requested = false;
+	if (!vb2_start_streaming_called(q))
+		v4l2_m2m_update_stop_streaming_state(sess->m2m_ctx, q);
 }
 
 static const struct vb2_ops mali_vpu_vb2_ops = {
@@ -92,6 +124,8 @@ static const struct vb2_ops mali_vpu_vb2_ops = {
 	.buf_prepare		= mali_vpu_vb2_buffer_prepare,
 	.buf_queue		= mali_vpu_vb2_buffer_queue,
 	.prepare_streaming	= mali_vpu_vb2_prepare_streaming,
+	.start_streaming	= mali_vpu_vb2_start_streaming,
+	.stop_streaming		= mali_vpu_vb2_stop_streaming,
 	.unprepare_streaming	= mali_vpu_vb2_unprepare_streaming,
 };
 
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-vidioc.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-vidioc.c
index d9196cc86cdf4..0fcd3835e52d3 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-vidioc.c
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-vidioc.c
@@ -357,4 +357,6 @@ const struct v4l2_ioctl_ops mali_vpu_ioctl_ops_dec = {
 	.vidioc_enum_framesizes		= mali_vpu_enum_framesizes,
 	.vidioc_subscribe_event		= mali_vpu_subscribe_event,
 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
+	.vidioc_streamon		= v4l2_m2m_ioctl_streamon,
+	.vidioc_streamoff		= v4l2_m2m_ioctl_streamoff,
 };
-- 
2.43.0


  parent reply	other threads:[~2026-11-19 15:39 UTC|newest]

Thread overview: 29+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19 15:37 [RFC PATCH 00/28] media: add arm Mali-V76 video decoder driver Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 01/28] dt-bindings: media: add Arm Mali-V76 VPU Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 02/28] media: mali-vpu: add Mali VPU platform driver Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 03/28] media: mali-vpu: register V4L2 decoder device and add querycap ioctl Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 04/28] media: mali-vpu: initialize decoder format state Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 05/28] media: mali-vpu: add V4L2 mem2mem and VB2 queue support Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 06/28] media: mali-vpu: implement format query ioctls Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 07/28] media: mali-vpu: implement TRY_FMT and S_FMT ioctls Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 08/28] media: mali-vpu: register V76 decoder controls and introduce UAPI controls Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 09/28] media: mali-vpu: add MMU software page table manager Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 10/28] media: mali-vpu: add firmware cache infrastructure Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 11/28] media: mali-vpu: load firmware for decoder sessions Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 12/28] media: mali-vpu: prepare firmware address space Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 13/28] media: mali-vpu: add firmware message transport Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 14/28] media: mali-vpu: route decoder controls to firmware Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 15/28] media: mali-vpu: handle firmware RPC requests Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 16/28] media: mali-vpu: add LSID hardware support Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 17/28] media: mali-vpu: add single session scheduler Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 18/28] media: mali-vpu: handle firmware interrupts Charvi Mehta
2026-11-19 15:37 ` Charvi Mehta [this message]
2026-11-19 15:37 ` [RFC PATCH 20/28] media: mali-vpu: implement vb2 buffer queue handling Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 21/28] media: mali-vpu: handle firmware buffer exchange Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 22/28] media: mali-vpu: handle fatal firmware error Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 23/28] media: mali-vpu: propagate buffer metadata Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 24/28] media: mali-vpu: add decoder EOS and DRC handling Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 25/28] media: mali-vpu: handle firmware buffer parameters Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 26/28] media: mali-vpu: handle firmware event responses Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 27/28] media: mali-vpu: add stateful decoder state machine Charvi Mehta
2026-11-19 15:37 ` [RFC PATCH 28/28] media: MAINTAINERS: add Arm Mali-V76 VPU driver Charvi Mehta

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261119153758.1426673-20-charvi.mehta@arm.com \
    --to=charvi.mehta@arm.com \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=krzk+dt@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-media@vger.kernel.org \
    --cc=mchehab@kernel.org \
    --cc=p.zabel@pengutronix.de \
    --cc=rath.sankaralingam@arm.com \
    --cc=robh@kernel.org \
    --cc=shobhit.pandey@arm.com \
    --cc=vincenzo.frascino@arm.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®