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

Handle firmware requests for debug output and memory allocation,
resizing and release. Track allocations by firmware virtual address
and release outstanding allocations during firmware teardown.

Flag resize and free requests so the caller can invalidate cached
firmware MMU translations before resuming execution.

Signed-off-by: Charvi Mehta <charvi.mehta@arm.com>
---
 .../platform/arm/mali-vpu/mali-vpu-firmware.c | 277 ++++++++++++++++++
 .../platform/arm/mali-vpu/mali-vpu-firmware.h |  12 +
 .../arm/mali-vpu/mali-vpu-protocol-def-v3.h   |  53 ++++
 3 files changed, 342 insertions(+)

diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.c b/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.c
index 91a989c098cbc..c11d5c6c0ec5f 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.c
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.c
@@ -7,6 +7,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/err.h>
 #include <linux/errno.h>
+#include <linux/sizes.h>
 #include <linux/string.h>
 
 #include "mali-vpu-firmware.h"
@@ -15,6 +16,7 @@
 #include "mali-vpu-protocol-def-v3.h"
 
 #define MALI_VPU_FW_MAX_CORES 8
+#define MALI_VPU_RPC_VA_GRANULE SZ_16M
 
 static int mali_vpu_fw_get_region(enum mali_vpu_fw_region region,
 				  mali_vpu_mmu_va *begin, mali_vpu_mmu_va *end)
@@ -80,6 +82,14 @@ static int mali_vpu_fw_get_region(enum mali_vpu_fw_region region,
 		*begin = MVE_MEM_REGION_FW_INSTANCE7_ADDR_BEGIN;
 		*end = MVE_MEM_REGION_FW_INSTANCE7_ADDR_END;
 		break;
+	case MALI_VPU_FW_REGION_PROTECTED:
+		*begin = MVE_MEM_REGION_PROTECTED_ADDR_BEGIN;
+		*end = MVE_MEM_REGION_PROTECTED_ADDR_END;
+		break;
+	case MALI_VPU_FW_REGION_FRAMEBUF:
+		*begin = MVE_MEM_REGION_FRAMEBUF_ADDR_BEGIN;
+		*end = MVE_MEM_REGION_FRAMEBUF_ADDR_END;
+		break;
 	default:
 		return -EINVAL;
 	}
@@ -352,6 +362,7 @@ int mali_vpu_fw_construct(struct mali_vpu_fw *fw, const struct mali_vpu_fw_bin *
 	fw->dev = dev;
 	fw->mmu = mmu;
 	fw->ncores = ncores;
+	hash_init(fw->rpc_mem);
 
 	/* Initialise firmware core and protocol regions */
 	ret = mali_vpu_fw_map_core_regions(fw, fw_bin);
@@ -375,11 +386,21 @@ int mali_vpu_fw_construct(struct mali_vpu_fw *fw, const struct mali_vpu_fw_bin *
 
 void mali_vpu_fw_cleanup(struct mali_vpu_fw *fw)
 {
+	struct mali_vpu_mmu_pages *pages;
+	struct hlist_node *tmp;
+	unsigned int bkt;
+
 	if (!fw)
 		return;
 
 	mali_vpu_fw_unmap_protocol(fw);
 	mali_vpu_fw_unmap_core_regions(fw);
+
+	hash_for_each_safe(fw->rpc_mem, bkt, tmp, pages, node) {
+		hash_del(&pages->node);
+		mali_vpu_mmu_free_pages(pages);
+	}
+
 	memset(fw, 0, sizeof(*fw));
 }
 
@@ -908,3 +929,259 @@ int mali_vpu_fw_parse_msg(struct mali_vpu_fw *fw, struct mali_vpu_fw_msg *msg)
 
 	return ret;
 }
+
+static void mali_vpu_fw_dbg_rpc(struct mali_vpu_fw *fw, const char *direction,
+				const struct mve_rpc_communication_area *rpc)
+{
+	dev_dbg(fw->dev, "rpc %s: state=%u call_id=%u size=%u\n",
+		direction, rpc->state, rpc->call_id, rpc->size);
+}
+
+static struct mali_vpu_mmu_pages *mali_vpu_find_pages(struct mali_vpu_fw *fw,
+						      mali_vpu_mmu_va va)
+{
+	struct mali_vpu_mmu_pages *pages;
+
+	hash_for_each_possible(fw->rpc_mem, pages, node, va) {
+		if (pages->va == va)
+			return pages;
+	}
+
+	return NULL;
+}
+
+static void mali_vpu_rpc_mem_resize(struct mali_vpu_fw *fw,
+				    struct mve_rpc_communication_area *rpc_area)
+{
+	union mve_rpc_params *p = &rpc_area->params;
+	struct mali_vpu_mmu_pages *pages;
+	mali_vpu_mmu_va va = 0;
+	int ret;
+
+	pages = mali_vpu_find_pages(fw, p->mem_resize.ve_pointer);
+	if (pages) {
+		size_t npages;
+
+		/* Resize the allocated pages. */
+		npages = DIV_ROUND_UP(p->mem_resize.new_size, MALI_VPU_PAGE_SIZE);
+		ret = mali_vpu_mmu_resize_pages(pages, npages);
+		if (ret) {
+			dev_warn(fw->dev,
+				 "failed to resize RPC mapped pages. ret=%d\n",
+				 ret);
+			goto err;
+		}
+
+		va = pages->va;
+	} else {
+		dev_warn(fw->dev, "could not find pages for RPC resize. va=0x%x\n",
+			 p->mem_resize.ve_pointer);
+	}
+
+	dev_dbg(fw->dev, "RPC resize memory. va=0x%x, new_size=%u\n",
+		p->mem_resize.ve_pointer, p->mem_resize.new_size);
+
+err:
+	/*
+	 * The memory RPC ABI returns the resulting firmware VA. Firmware treats
+	 * a zero VA as allocation failure and reports MVE_ERROR_OUT_OF_MEMORY.
+	 * The RPC itself was still handled successfully.
+	 */
+	rpc_area->size = sizeof(u32);
+	p->data[0] = va;
+}
+
+static void mali_vpu_rpc_mem_alloc(struct mali_vpu_fw *fw,
+				   struct mve_rpc_communication_area *rpc_area)
+{
+	union mve_rpc_params *p = &rpc_area->params;
+	enum mali_vpu_fw_region region;
+	struct mali_vpu_mmu_pages *pages;
+	size_t npages, max_pages;
+	mali_vpu_mmu_va end, begin = 0;
+	int ret;
+
+	if (!p->mem_alloc.size ||
+	    p->mem_alloc.size > p->mem_alloc.max_size) {
+		dev_warn(fw->dev,
+			 "invalid RPC allocation:size=%u max_size=%u alignment=%u\n",
+			 p->mem_alloc.size, p->mem_alloc.max_size,
+			 p->mem_alloc.log2_alignment);
+		goto err;
+	}
+
+	switch (p->mem_alloc.region) {
+	case MVE_MEM_REGION_PROTECTED:
+		region = MALI_VPU_FW_REGION_PROTECTED;
+		break;
+	case MVE_MEM_REGION_OUTBUF:
+		region = MALI_VPU_FW_REGION_FRAMEBUF;
+		break;
+	default:
+		dev_err(fw->dev,
+			"unsupported RPC mem alloc region. region=%u\n",
+			p->mem_alloc.region);
+		goto err;
+	}
+
+	ret = mali_vpu_fw_get_region(region, &begin, &end);
+	if (ret)
+		goto err;
+
+	npages = DIV_ROUND_UP(p->mem_alloc.size, MALI_VPU_PAGE_SIZE);
+	max_pages = DIV_ROUND_UP(p->mem_alloc.max_size, MALI_VPU_PAGE_SIZE);
+
+	pages = mali_vpu_mmu_alloc_pages(fw->dev, npages, max_pages);
+	if (IS_ERR(pages)) {
+		begin = 0;
+		goto err;
+	}
+
+	ret = -EINVAL;
+	while (begin < end) {
+		ret = mali_vpu_mmu_map_pages(fw->mmu, begin, pages,
+					     MALI_VPU_ATTR_SHARED_RW,
+					     MALI_VPU_ACCESS_READ_WRITE);
+		if (!ret)
+			break;
+
+		begin += MALI_VPU_RPC_VA_GRANULE;
+	}
+
+	if (ret) {
+		dev_err(fw->dev,
+			"failed to find memory region for RPC alloc.\n");
+		mali_vpu_mmu_free_pages(pages);
+		begin = 0;
+		goto err;
+	}
+
+	hash_add(fw->rpc_mem, &pages->node, pages->va);
+	begin = pages->va;
+
+	dev_dbg(fw->dev,
+		"RPC alloc memory. size=%u, max_size=%u, region=%u, npages=%zu, begin=0x%x\n",
+		p->mem_alloc.size, p->mem_alloc.max_size, p->mem_alloc.region, npages, begin);
+
+err:
+	rpc_area->size = sizeof(u32);
+	p->data[0] = begin;
+}
+
+static void mali_vpu_rpc_mem_free(struct mali_vpu_fw *fw,
+				  struct mve_rpc_communication_area *rpc_area)
+{
+	union mve_rpc_params *p = &rpc_area->params;
+	struct mali_vpu_mmu_pages *pages;
+
+	pages = mali_vpu_find_pages(fw, p->mem_free.ve_pointer);
+	if (pages) {
+		hash_del(&pages->node);
+		mali_vpu_mmu_free_pages(pages);
+	} else {
+		dev_warn(fw->dev,
+			 "could not find pages for RPC free. va=0x%x\n",
+			 p->mem_free.ve_pointer);
+	}
+
+	dev_dbg(fw->dev, "RPC free memory. va=0x%x\n", p->mem_free.ve_pointer);
+
+	rpc_area->size = 0;
+}
+
+int mali_vpu_fw_handle_rpc(struct mali_vpu_fw *fw, bool *flush_mmu)
+{
+	struct mve_rpc_communication_area *rpc_area = fw->rpc.cpu;
+	int ret = 0;
+
+	if (flush_mmu)
+		*flush_mmu = false;
+
+	dma_sync_single_for_cpu(fw->dev, fw->rpc.dma, sizeof(*rpc_area),
+				DMA_FROM_DEVICE);
+
+	if (READ_ONCE(rpc_area->state) == MVE_RPC_STATE_PARAM) {
+		/*
+		 * Firmware publishes param only after writing the RPC request.
+		 */
+		dma_rmb();
+
+		ret = 1;
+
+		mali_vpu_fw_dbg_rpc(fw, "fw->host", rpc_area);
+
+		switch (rpc_area->call_id) {
+		case MVE_RPC_FUNCTION_DEBUG_PRINTF: {
+			if (!rpc_area->size ||
+			    rpc_area->size > sizeof(rpc_area->params.debug_print.string)) {
+				ret = -EPROTO;
+				rpc_area->size = 0;
+				break;
+			}
+
+			const char *s = rpc_area->params.debug_print.string;
+			size_t len = strnlen(s, rpc_area->size);
+
+			/* Strip trailing characters */
+			while (len && (s[len - 1] == '\n' || s[len - 1] == '\r'))
+				len--;
+
+			dev_info(fw->dev,
+				 "firmware DEBUG Print: %.*s\n", (int)len, s);
+			break;
+		}
+		case MVE_RPC_FUNCTION_MEM_ALLOC: {
+			if (rpc_area->size != sizeof(rpc_area->params.mem_alloc)) {
+				ret = -EPROTO;
+				break;
+			}
+
+			mali_vpu_rpc_mem_alloc(fw, rpc_area);
+			break;
+		}
+		case MVE_RPC_FUNCTION_MEM_RESIZE: {
+			if (rpc_area->size != sizeof(rpc_area->params.mem_resize)) {
+				ret = -EPROTO;
+				break;
+			}
+
+			mali_vpu_rpc_mem_resize(fw, rpc_area);
+			if (flush_mmu)
+				*flush_mmu = true;
+			break;
+		}
+		case MVE_RPC_FUNCTION_MEM_FREE: {
+			if (rpc_area->size != sizeof(rpc_area->params.mem_free)) {
+				ret = -EPROTO;
+				break;
+			}
+
+			mali_vpu_rpc_mem_free(fw, rpc_area);
+			if (flush_mmu)
+				*flush_mmu = true;
+			break;
+		}
+		default:
+			dev_warn_ratelimited(fw->dev,
+					     "unsupported RPC request. call_id=%u\n",
+					     rpc_area->call_id);
+			ret = -EOPNOTSUPP;
+			break;
+		}
+
+		/*
+		 * Make sure the whole RPC message body has been written before
+		 * the RPC message area is returned to the firmware.
+		 */
+		dma_wmb();
+		WRITE_ONCE(rpc_area->state, MVE_RPC_STATE_RETURN);
+
+		dma_sync_single_for_device(fw->dev, fw->rpc.dma,
+					   sizeof(*rpc_area), DMA_TO_DEVICE);
+
+		/* Log RPC response. */
+		mali_vpu_fw_dbg_rpc(fw, "host->fw", rpc_area);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.h
index e5dd67ce3397a..c03a07d994873 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.h
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-firmware.h
@@ -6,9 +6,11 @@
 #ifndef __MALI_VPU_FIRMWARE_H__
 #define __MALI_VPU_FIRMWARE_H__
 
+#include <linux/hashtable.h>
 #include <linux/media/arm/mali-vpu-config.h>
 #include <linux/types.h>
 
+#define MALI_VPU_FW_HTABLE_BITS 3
 #define MALI_VPU_FW_TEXT_BASE_ADDR 0x1000u
 
 struct device;
@@ -156,6 +158,8 @@ struct mali_vpu_fw_msg {
  * @MALI_VPU_FW_REGION_CORE_5: Firmware instance region for core 5.
  * @MALI_VPU_FW_REGION_CORE_6: Firmware instance region for core 6.
  * @MALI_VPU_FW_REGION_CORE_7: Firmware instance region for core 7.
+ * @MALI_VPU_FW_REGION_PROTECTED: Protected firmware memory region.
+ * @MALI_VPU_FW_REGION_FRAMEBUF: Frame-buffer memory region.
  */
 enum mali_vpu_fw_region {
 	MALI_VPU_FW_REGION_MSG_HOST,
@@ -175,6 +179,9 @@ enum mali_vpu_fw_region {
 	MALI_VPU_FW_REGION_CORE_5,
 	MALI_VPU_FW_REGION_CORE_6,
 	MALI_VPU_FW_REGION_CORE_7,
+
+	MALI_VPU_FW_REGION_PROTECTED,
+	MALI_VPU_FW_REGION_FRAMEBUF,
 };
 
 /**
@@ -207,6 +214,8 @@ struct mali_vpu_fw_proto_page {
  * @shared_bss_pages: Shared BSS pages mapped into every core instance.
  * @ncores: Number of firmware core-instance regions constructed.
  * @pending_response_count: Number of requests awaiting a firmware response.
+ * @rpc_mem: Keeps track of RPC allocated memory. Maps MVE virtual address to
+ *		'struct mali_vpu_mmu_pages' object.
  */
 struct mali_vpu_fw {
 	struct device *dev;
@@ -225,6 +234,8 @@ struct mali_vpu_fw {
 	struct mali_vpu_mmu_pages *shared_bss_pages;
 	u32 ncores;
 	u32 pending_response_count;
+
+	DECLARE_HASHTABLE(rpc_mem, MALI_VPU_FW_HTABLE_BITS);
 };
 
 int mali_vpu_fw_construct(struct mali_vpu_fw *fw, const struct mali_vpu_fw_bin *fw_bin,
@@ -235,5 +246,6 @@ int mali_vpu_fw_send_ping(struct mali_vpu_fw *fw);
 int mali_vpu_fw_send_state_change(struct mali_vpu_fw *fw, enum mali_vpu_fw_state state);
 int mali_vpu_fw_send_set_option(struct mali_vpu_fw *fw, struct mali_vpu_fw_set_option *option);
 int mali_vpu_fw_parse_msg(struct mali_vpu_fw *fw, struct mali_vpu_fw_msg *msg);
+int mali_vpu_fw_handle_rpc(struct mali_vpu_fw *fw, bool *flush_mmu);
 
 #endif /* __MALI_VPU_FIRMWARE_H__ */
diff --git a/drivers/media/platform/arm/mali-vpu/mali-vpu-protocol-def-v3.h b/drivers/media/platform/arm/mali-vpu/mali-vpu-protocol-def-v3.h
index c7c18bd4e1551..8a81ed1fd730a 100644
--- a/drivers/media/platform/arm/mali-vpu/mali-vpu-protocol-def-v3.h
+++ b/drivers/media/platform/arm/mali-vpu/mali-vpu-protocol-def-v3.h
@@ -77,6 +77,16 @@
  * 0x10079000 - 0x1007FFFF, see special defines further down.
  */
 
+/* PROTECTED virtual memory region */
+#define MVE_MEM_REGION_PROTECTED_ADDR_BEGIN	(0x20000000u)
+#define MVE_MEM_REGION_PROTECTED_ADDR_END	(0x6FFFFFFFu + 1)
+
+/* FRAMEBUF virtual memory region */
+#define MVE_MEM_REGION_FRAMEBUF_ADDR_BEGIN	(0x70000000u)
+#define MVE_MEM_REGION_FRAMEBUF_ADDR_END	(0xEFFFFFFFu + 1)
+
+/* 0xF0000000 - 0xFFFFFFFF is used internally in MVE */
+
 /*****************************************************************************
  *
  * Communication queues between HOST/DRIVER and MVE
@@ -153,6 +163,49 @@ struct mve_comm_area_mve {
 	u32 out_data[MVE_COMM_QUEUE_SIZE_IN_WORDS];
 };
 
+#define MVE_RPC_AREA_SIZE_IN_WORDS 256
+#define MVE_RPC_DATA_SIZE_IN_WORDS (MVE_RPC_AREA_SIZE_IN_WORDS - 3)
+union mve_rpc_params {
+	u32 data[MVE_RPC_DATA_SIZE_IN_WORDS];
+	struct {
+		char string[MVE_RPC_DATA_SIZE_IN_WORDS * 4];
+	} debug_print;
+	struct {
+		u32 size;
+		u32 max_size;
+		u8 region; /* Memory region selection */
+			#define MVE_MEM_REGION_PROTECTED (0)
+			#define MVE_MEM_REGION_OUTBUF    (1)
+			#define MVE_MEM_REGION_FRAMEBUF  (MVE_MEM_REGION_OUTBUF)
+
+		/* The newly allocated memory must be placed
+		 * on (at least) a 2^(log2_alignment) boundary
+		 */
+		u8 log2_alignment;
+	} mem_alloc;
+	struct {
+		u32 ve_pointer;
+		u32 new_size;
+	} mem_resize;
+	struct {
+		u32 ve_pointer;
+	} mem_free;
+};
+
+struct mve_rpc_communication_area {
+	u32 state;
+		#define MVE_RPC_STATE_FREE   (0)
+		#define MVE_RPC_STATE_PARAM  (1)
+		#define MVE_RPC_STATE_RETURN (2)
+	u32 call_id;
+		#define MVE_RPC_FUNCTION_DEBUG_PRINTF (1)
+		#define MVE_RPC_FUNCTION_MEM_ALLOC    (2)
+		#define MVE_RPC_FUNCTION_MEM_RESIZE   (3)
+		#define MVE_RPC_FUNCTION_MEM_FREE     (4)
+	u32 size;
+	union mve_rpc_params params;
+};
+
 /*********************************************************************
  *
  *   Message codes
-- 
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 ` Charvi Mehta [this message]
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 ` [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-16-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®