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 16/28] media: mali-vpu: add LSID hardware support
Date: Thu, 19 Nov 2026 15:37:46 +0000	[thread overview]
Message-ID: <20261119153758.1426673-17-charvi.mehta@arm.com> (raw)
In-Reply-To: <20261119153758.1426673-1-charvi.mehta@arm.com>

Add low-level support of managing the VPU local session IDs (LSIDs).
Define the per-LSID and job queue registers and provide helpers to map and
unmap sessions, manage the job queue, signal firmware, flush the session
MMU and terminate execution.

These operations provide hardware interface for the scheduler added
in a subsequent patch.

Signed-off-by: Charvi Mehta <charvi.mehta@arm.com>
---
 drivers/media/platform/arm/mali-vpu/Makefile  |   3 +-
 .../platform/arm/mali-vpu/mali-vpu-lsid.c     | 271 ++++++++++++++++++
 .../platform/arm/mali-vpu/mali-vpu-lsid.h     |  55 ++++
 .../arm/mali-vpu/mali-vpu-registers.h         |  44 ++-
 4 files changed, 370 insertions(+), 3 deletions(-)
 create mode 100644 drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.c
 create mode 100644 drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.h

diff --git a/drivers/media/platform/arm/mali-vpu/Makefile b/drivers/media/platform/arm/mali-vpu/Makefile
index 168b4bc43d54d..51d49d815f1fb 100644
--- a/drivers/media/platform/arm/mali-vpu/Makefile
+++ b/drivers/media/platform/arm/mali-vpu/Makefile
@@ -11,6 +11,7 @@ mali-vpu-objs := mali-vpu-probe.o \
 		mali-vpu-controls.o \
 		mali-vpu-mmu.o \
 		mali-vpu-firmware-cache.o \
-		mali-vpu-firmware.o
+		mali-vpu-firmware.o \
+		mali-vpu-lsid.o
 
 obj-$(CONFIG_VIDEO_MALI_VPU) += mali-vpu.o
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.c
new file mode 100644
index 0000000000000..42bf32b0937ff
--- /dev/null
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.c
@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2026 ARM Limited.
+ */
+
+#include <linux/iopoll.h>
+
+#include "mali-vpu-device.h"
+#include "mali-vpu-lsid.h"
+#include "mali-vpu-registers.h"
+
+#define MALI_VPU_TERMINATE_READ_TIMEOUT_US  10000000
+#define MALI_VPU_TERMINATE_POLL_INTERVAL_US 10
+
+static u32 mali_vpu_lsid_reg(u32 lsid, u32 off)
+{
+	return MALI_VPU_LSID_BASE + (MALI_VPU_LSID_STRIDE * lsid) + off;
+}
+
+static u32 mali_vpu_read_lsid(void __iomem *regs_base, u32 lsid, u32 off)
+{
+	return mali_vpu_read_reg(regs_base, mali_vpu_lsid_reg(lsid, off));
+}
+
+static void mali_vpu_write_lsid(void __iomem *regs_base, u32 lsid, u32 off, u32 val)
+{
+	mali_vpu_write_reg(regs_base, mali_vpu_lsid_reg(lsid, off), val);
+}
+
+static bool mali_vpu_is_lsid_allocated(struct mali_vpu_lsid *lsid)
+{
+	u32 alloc = mali_vpu_read_lsid(lsid->vpu_dev->regs_base, lsid->id,
+				       MALI_VPU_REG_LSID_ALLOC);
+
+	return alloc != MALI_VPU_ALLOC_FREE;
+}
+
+static u32 mali_vpu_jobqueue_get_lsid(u32 jobqueue, u32 job)
+{
+	u32 shift = MALI_VPU_JOBQUEUE_JOB_STRIDE * job;
+	u32 lsid_mask = (1 << MALI_VPU_JOBQUEUE_LSID_BITS) - 1;
+
+	return (jobqueue >> shift) & lsid_mask;
+}
+
+static u32 mali_vpu_jobqueue_get_ncores_minus1(u32 jobqueue, u32 job)
+{
+	u32 shift = (MALI_VPU_JOBQUEUE_JOB_STRIDE * job) + MALI_VPU_JOBQUEUE_LSID_BITS;
+	u32 ncores_mask = (1 << MALI_VPU_JOBQUEUE_NCORES_BITS) - 1;
+
+	return (jobqueue >> shift) & ncores_mask;
+}
+
+static u32 mali_vpu_jobqueue_set_job(u32 jobqueue, u32 job_id, u32 lsid,
+				     u32 ncores_minus1)
+{
+	u32 shift = MALI_VPU_JOBQUEUE_JOB_STRIDE * job_id;
+	u32 job_mask = ((1u << MALI_VPU_JOBQUEUE_JOB_STRIDE) - 1) << shift;
+	u32 job_val, lsid_mask, ncores_mask;
+
+	lsid_mask = ((1u << MALI_VPU_JOBQUEUE_LSID_BITS) - 1);
+	ncores_mask = ((1u << MALI_VPU_JOBQUEUE_NCORES_BITS) - 1);
+
+	job_val = lsid & lsid_mask;
+	job_val |= (ncores_minus1 & ncores_mask) << MALI_VPU_JOBQUEUE_LSID_BITS;
+
+	return (jobqueue & ~job_mask) | (job_val << shift);
+}
+
+int mali_vpu_lsid_terminate(struct mali_vpu_lsid *lsid)
+{
+	struct mali_vpu_dev *vpu_dev = lsid->vpu_dev;
+	u32 val;
+
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_TERMINATE, 1);
+
+	return read_poll_timeout(mali_vpu_read_lsid, val, val == 0,
+				MALI_VPU_TERMINATE_POLL_INTERVAL_US,
+				MALI_VPU_TERMINATE_READ_TIMEOUT_US, false,
+				vpu_dev->regs_base, lsid->id,
+				MALI_VPU_REG_LSID_TERMINATE);
+}
+
+void mali_vpu_lsid_init(struct mali_vpu_lsid *lsid, struct mali_vpu_dev *dev, u32 id)
+{
+	lsid->vpu_dev = dev;
+	lsid->id = id;
+}
+
+int mali_vpu_lsid_map(struct mali_vpu_lsid *lsid, struct mali_vpu_lsid_pcb *pcb)
+{
+	struct mali_vpu_dev *vpu_dev = lsid->vpu_dev;
+	u32 alloc;
+	int ret;
+
+	/* Check that the LSID is not already allocated. */
+	if (mali_vpu_is_lsid_allocated(lsid)) {
+		dev_err(vpu_dev->dev,
+			"failed to map session to LSID. LSID already allocated. lsid=%u\n",
+			lsid->id);
+		return -EBUSY;
+	}
+
+	/* Allocate LSID. */
+	alloc = pcb->nprot == 0 ? MALI_VPU_ALLOC_PROTECTED : MALI_VPU_ALLOC_NON_PROTECTED;
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_ALLOC, alloc);
+
+	if (mali_vpu_read_lsid(vpu_dev->regs_base, lsid->id,
+			       MALI_VPU_REG_LSID_NPROT) != pcb->nprot) {
+		dev_err(vpu_dev->dev,
+			"unexpected protection state for LSID %u\n", lsid->id);
+		mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id,
+				    MALI_VPU_REG_LSID_ALLOC, MALI_VPU_ALLOC_FREE);
+		return -EIO;
+	}
+
+	/* Ensure that the cores have stopped executing any session previously mapped. */
+	ret = mali_vpu_lsid_terminate(lsid);
+	if (ret) {
+		dev_err(vpu_dev->dev, "failed to terminate LSID %u: %d\n",
+			lsid->id, ret);
+		/*
+		 * The caller must reset the VPU on termination timeout. The
+		 * LSID cannot safely be marked free while hardware activity
+		 * is uncertain.
+		 */
+		return ret;
+	}
+
+	/* Configure number of cores to use and which cores to disable. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_CTRL, pcb->ctrl);
+
+	/* Configure MMU L0 entry and flush MMU tables. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_MMU_CTRL,
+			    pcb->mmu_ctrl);
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_FLUSH_ALL, 0);
+
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_BUSATTR_0, 0x0);
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_BUSATTR_1, 0x0);
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_BUSATTR_2, 0x33);
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_BUSATTR_3, 0x33);
+
+	/* Restore interrupt registers. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_IRQVE, 0);
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_IRQHOST, pcb->irqhost);
+
+	/*
+	 * Order the configuration writes before enabling scheduling.
+	 */
+	wmb();
+
+	/* Enable LSID for scheduling. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_SCHED, 1);
+
+	return 0;
+}
+
+/*
+ * An LSID must not be unmapped if it is present in the job queue or core LSID.
+ * It is the responsibility of the scheduler to guarantee that the LSID is idle
+ * before it is unmapped.
+ */
+void mali_vpu_lsid_unmap(struct mali_vpu_lsid *lsid, struct mali_vpu_lsid_pcb *pcb)
+{
+	struct mali_vpu_dev *vpu_dev = lsid->vpu_dev;
+
+	if (!mali_vpu_is_lsid_allocated(lsid)) {
+		dev_dbg(vpu_dev->dev, "no session mapped to LSID %u\n", lsid->id);
+		return;
+	}
+
+	/* Prevent the LSID from being scheduled. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_SCHED, 0);
+
+	/* Store registers in process control block. */
+	pcb->ctrl = mali_vpu_read_lsid(vpu_dev->regs_base, lsid->id,
+				       MALI_VPU_REG_LSID_CTRL);
+	pcb->mmu_ctrl = mali_vpu_read_lsid(vpu_dev->regs_base, lsid->id,
+					   MALI_VPU_REG_LSID_MMU_CTRL);
+	pcb->irqhost = mali_vpu_read_lsid(vpu_dev->regs_base, lsid->id,
+					  MALI_VPU_REG_LSID_IRQHOST);
+	pcb->nprot = mali_vpu_read_lsid(vpu_dev->regs_base, lsid->id,
+					MALI_VPU_REG_LSID_NPROT);
+
+	/* Deallocate LSID. */
+	mali_vpu_write_lsid(vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_ALLOC,
+			    MALI_VPU_ALLOC_FREE);
+}
+
+int mali_vpu_lsid_jobqueue_add(struct mali_vpu_lsid *lsid, u32 ncores)
+{
+	struct mali_vpu_dev *vpu_dev = lsid->vpu_dev;
+	u32 jobqueue;
+	int job, ret = -EAGAIN;
+
+	if (!ncores || ncores > BIT(MALI_VPU_JOBQUEUE_NCORES_BITS))
+		return -EINVAL;
+
+	/* Stop the hardware scheduler while updating the jobqueue. */
+	mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_ENABLE, 0);
+
+	jobqueue = mali_vpu_read_reg(vpu_dev->regs_base, MALI_VPU_REG_JOBQUEUE);
+
+	/* Search if the LSID is already in the job queue. */
+	for (job = 0; job < MALI_VPU_JOBQUEUE_NJOBS; job++)
+		if (mali_vpu_jobqueue_get_lsid(jobqueue, job) == lsid->id) {
+			ret = 0;
+			goto enable_hw_scheduler;
+		}
+
+	/* Search for a free slot in the job queue. */
+	for (job = 0; job < MALI_VPU_JOBQUEUE_NJOBS; job++) {
+		if (mali_vpu_jobqueue_get_lsid(jobqueue, job) != MALI_VPU_JOBQUEUE_JOB_INVALID)
+			continue;
+
+		jobqueue = mali_vpu_jobqueue_set_job(jobqueue, job, lsid->id, ncores - 1);
+		mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_JOBQUEUE, jobqueue);
+		ret = 0;
+		break;
+	}
+
+enable_hw_scheduler:
+	mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_ENABLE, 1);
+	return ret;
+}
+
+void mali_vpu_lsid_jobqueue_remove(struct mali_vpu_lsid *lsid)
+{
+	struct mali_vpu_dev *vpu_dev = lsid->vpu_dev;
+	u32 old_jobqueue, new_jobqueue = 0;
+	u32 old_job_id, new_job_id, old_lsid, old_ncores_minus1;
+
+	/* Disable scheduling. */
+	mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_ENABLE, 0);
+
+	old_jobqueue = mali_vpu_read_reg(vpu_dev->regs_base, MALI_VPU_REG_JOBQUEUE);
+
+	/* Copy job entries that do not match the LSID to be removed. */
+	for (old_job_id = 0, new_job_id = 0; old_job_id < MALI_VPU_JOBQUEUE_NJOBS; old_job_id++) {
+		old_lsid          = mali_vpu_jobqueue_get_lsid(old_jobqueue, old_job_id);
+		old_ncores_minus1 = mali_vpu_jobqueue_get_ncores_minus1(old_jobqueue, old_job_id);
+
+		if (old_lsid == MALI_VPU_JOBQUEUE_JOB_INVALID ||
+		    old_lsid == lsid->id)
+			continue;
+
+		new_jobqueue = mali_vpu_jobqueue_set_job(new_jobqueue, new_job_id,
+							 old_lsid,
+							 old_ncores_minus1);
+		new_job_id++;
+	}
+
+	while (new_job_id < MALI_VPU_JOBQUEUE_NJOBS) {
+		new_jobqueue = mali_vpu_jobqueue_set_job(new_jobqueue, new_job_id,
+							 MALI_VPU_JOBQUEUE_JOB_INVALID, 0);
+		new_job_id++;
+	}
+
+	mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_JOBQUEUE, new_jobqueue);
+	mali_vpu_write_reg(vpu_dev->regs_base, MALI_VPU_REG_ENABLE, 1);
+}
+
+void mali_vpu_lsid_send_irq(struct mali_vpu_lsid *lsid)
+{
+	mali_vpu_write_lsid(lsid->vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_IRQHOST, 1);
+}
+
+void mali_vpu_lsid_flush_mmu(struct mali_vpu_lsid *lsid)
+{
+	mali_vpu_write_lsid(lsid->vpu_dev->regs_base, lsid->id, MALI_VPU_REG_LSID_FLUSH_ALL, 0);
+}
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.h
new file mode 100644
index 0000000000000..97c32f9ac9aa0
--- /dev/null
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-lsid.h
@@ -0,0 +1,55 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2026 ARM Limited.
+ */
+
+#ifndef __MALI_VPU_LSID_H__
+#define __MALI_VPU_LSID_H__
+
+#include <linux/types.h>
+
+struct mali_vpu_dev;
+
+/*
+ * A local session identifier (LSID) represents a hardware execution
+ * context. A firmware session must be mapped to an LSID before it can be
+ * scheduled on the VPU cores.
+ */
+
+/**
+ * struct mali_vpu_lsid_pcb - LSID process control block.
+ * @ctrl: Saved LSID control register value.
+ * @mmu_ctrl: Saved LSID MMU control register value.
+ * @irqhost: Saved pending host IRQ state.
+ * @nprot: Saved non-protected/protected allocation state.
+ *
+ * This structure is used to store the register map when a session is unmapped
+ * from a LSID, so it can be restored again when the session is remapped.
+ */
+struct mali_vpu_lsid_pcb {
+	u32 ctrl;
+	u32 mmu_ctrl;
+	u32 irqhost;
+	u32 nprot;
+};
+
+/**
+ * struct mali_vpu_lsid - Hardware LSID instance.
+ * @vpu_dev: Back pointer to parent Mali VPU device.
+ * @id: Hardware LSID instance.
+ */
+struct mali_vpu_lsid {
+	struct mali_vpu_dev *vpu_dev;
+	u32 id;
+};
+
+void mali_vpu_lsid_init(struct mali_vpu_lsid *lsid, struct mali_vpu_dev *vpu_dev, u32 id);
+int mali_vpu_lsid_map(struct mali_vpu_lsid *lsid, struct mali_vpu_lsid_pcb *pcb);
+void mali_vpu_lsid_unmap(struct mali_vpu_lsid *lsid, struct mali_vpu_lsid_pcb *pcb);
+int mali_vpu_lsid_jobqueue_add(struct mali_vpu_lsid *lsid, u32 ncores);
+void mali_vpu_lsid_jobqueue_remove(struct mali_vpu_lsid *lsid);
+void mali_vpu_lsid_send_irq(struct mali_vpu_lsid *lsid);
+void mali_vpu_lsid_flush_mmu(struct mali_vpu_lsid *lsid);
+int mali_vpu_lsid_terminate(struct mali_vpu_lsid *lsid);
+
+#endif /* __MALI_VPU_LSID_H__ */
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-registers.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-registers.h
index b7883b1ea47f3..f2386bdc4943a 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-registers.h
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-registers.h
@@ -14,8 +14,32 @@
  *
  * Offsets are relative to the VPU MMIO base.
  */
-#define MALI_VPU_REG_VERSION 0x00000
-#define MALI_VPU_REG_NCORES  0x00008
+#define MALI_VPU_REG_VERSION  0x00000
+#define MALI_VPU_REG_ENABLE   0x00004
+#define MALI_VPU_REG_NCORES   0x00008
+#define MALI_VPU_REG_JOBQUEUE 0x00014
+
+#define MALI_VPU_LSID_BASE    0x00200
+#define MALI_VPU_LSID_STRIDE  0x40
+
+/*
+ * Per-LSID registers.
+ * Address = MALI_VPU_LSID_BASE + (MALI_VPU_LSID_STRIDE * lsid) + per-LSID offset
+ * Each LSID has its own set of these registers, which are identical in layout.
+ */
+#define MALI_VPU_REG_LSID_CTRL      0x00
+#define MALI_VPU_REG_LSID_MMU_CTRL  0x04
+#define MALI_VPU_REG_LSID_NPROT     0x08
+#define MALI_VPU_REG_LSID_ALLOC     0x0C
+#define MALI_VPU_REG_LSID_FLUSH_ALL 0x10
+#define MALI_VPU_REG_LSID_SCHED     0x14
+#define MALI_VPU_REG_LSID_TERMINATE 0x18
+#define MALI_VPU_REG_LSID_IRQVE     0x1C
+#define MALI_VPU_REG_LSID_IRQHOST   0x20
+#define MALI_VPU_REG_LSID_BUSATTR_0 0x30
+#define MALI_VPU_REG_LSID_BUSATTR_1 0x34
+#define MALI_VPU_REG_LSID_BUSATTR_2 0x38
+#define MALI_VPU_REG_LSID_BUSATTR_3 0x3C
 
 /* Version register fields */
 #define MALI_VPU_VERSION_PRODUCT_ID_MASK GENMASK(31, 16)
@@ -23,9 +47,25 @@
 #define MALI_VPU_VERSION_PATCH_MASK      GENMASK(7, 0)
 #define MALI_VPU_PID_SUFFIX_MASK         GENMASK(15, 12)
 
+/* JOBQUEUE register: 4 entries x 8 bits (LSID[3:0], NCORES-1[7:4]) */
+#define MALI_VPU_JOBQUEUE_LSID_BITS   4
+#define MALI_VPU_JOBQUEUE_NCORES_BITS 4
+#define MALI_VPU_JOBQUEUE_JOB_STRIDE  8
+#define MALI_VPU_JOBQUEUE_JOB_INVALID 0xf
+#define MALI_VPU_JOBQUEUE_NJOBS       4
+
+#define MALI_VPU_ALLOC_FREE          0
+#define MALI_VPU_ALLOC_NON_PROTECTED 1
+#define MALI_VPU_ALLOC_PROTECTED     2
+
 static inline u32 mali_vpu_read_reg(void __iomem *regs_base, u32 off)
 {
 	return readl(regs_base + off);
 }
 
+static inline void mali_vpu_write_reg(void __iomem *regs_base, u32 off, u32 val)
+{
+	writel(val, regs_base + off);
+}
+
 #endif /* __MALI_VPU_REGISTERS_H__ */
-- 
2.43.0


  parent reply	other threads:[~2026-11-19 15:38 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 ` Charvi Mehta [this message]
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 ` [RFC PATCH 19/28] media: mali-vpu: start decoder firmware through LSID scheduling Charvi Mehta
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-17-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®