mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Gregory Williams <gregory.williams@amd.com>
To: Oded Gabbay <ogabbay@kernel.org>
Cc: <linux-kernel@vger.kernel.org>, <dri-devel@lists.freedesktop.org>
Subject: [PATCH 14/15] accel/amd-ai-engine: Add support to enable/disable tile clocks
Date: Wed, 18 Nov 2026 15:32:10 -0800	[thread overview]
Message-ID: <20261118233211.4121361-15-gregory.williams@amd.com> (raw)
In-Reply-To: <20261118233211.4121361-1-gregory.williams@amd.com>

Add support for enabling tile clocks and requesting/releasing tiles.
Requesting tiles will enable the clocks of the tiles requested, releasing
tiles will disable the tile clocks.

Signed-off-by: Gregory Williams <gregory.williams@amd.com>
---
 drivers/accel/amd-ai-engine/Makefile          |   1 +
 .../accel/amd-ai-engine/ai-engine-aiemlv2.c   | 150 +++++++++++++++++
 drivers/accel/amd-ai-engine/ai-engine-clock.c | 154 ++++++++++++++++++
 .../accel/amd-ai-engine/ai-engine-internal.h  |  43 +++++
 drivers/accel/amd-ai-engine/ai-engine-part.c  |  18 ++
 drivers/accel/amd-ai-engine/ai-engine-res.c   |  56 +++++++
 include/linux/amd-ai-engine.h                 |   1 -
 7 files changed, 422 insertions(+), 1 deletion(-)
 create mode 100644 drivers/accel/amd-ai-engine/ai-engine-clock.c

diff --git a/drivers/accel/amd-ai-engine/Makefile b/drivers/accel/amd-ai-engine/Makefile
index 8b0d857d3347..c6d090257d6e 100644
--- a/drivers/accel/amd-ai-engine/Makefile
+++ b/drivers/accel/amd-ai-engine/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_DRM_ACCEL_AMDAIE)	+= amd-aie.o
 amd-aie-$(CONFIG_DRM_ACCEL_AMDAIE) := \
 	ai-engine-aiemlv2.o	\
 	ai-engine-dev.o		\
+	ai-engine-clock.o	\
 	ai-engine-part.o	\
 	ai-engine-pm.o		\
 	ai-engine-res.o
diff --git a/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c b/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
index 0c9c7ccdd54e..26dd1d726bfa 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
@@ -13,6 +13,16 @@
 #define AIEMLV2_COL_SHIFT		25U
 #define AIEMLV2_ROW_SHIFT		20U
 
+/*
+ * Register offsets
+ */
+#define AIEMLV2_SHIMPL_COLCLOCK_CTRL_REGOFF		0x0007FF20U
+
+/*
+ * Register masks
+ */
+#define AIEMLV2_SHIMPL_COLCLOCK_CTRL_MASK		GENMASK(1, 0)
+
 static u32 aiemlv2_get_tile_type(struct aie_device *adev, struct aie_location *loc)
 {
 	u8 num_mem_rows = adev->ttype_attr[AIE_TILE_TYPE_MEMORY].num_rows;
@@ -25,8 +35,148 @@ static u32 aiemlv2_get_tile_type(struct aie_device *adev, struct aie_location *l
 	return AIE_TILE_TYPE_SHIMNOC;
 }
 
+static int aiemlv2_scan_part_clocks(struct aie_partition *apart)
+{
+	struct aie_range *range = &apart->range;
+	struct aie_device *adev = apart->adev;
+	struct aie_location loc;
+
+	/* Clear the bitmap of cores and memories clock state */
+	aie_resource_put_region(&apart->cores_clk_state, 0,
+				apart->cores_clk_state.total);
+
+	/*
+	 * If the clock buffer on shim tile is enabled, then all tiles above in
+	 * the same column are also enabled.
+	 */
+
+	loc.row = 0;
+	for (loc.col = range->start.col;
+	     loc.col < range->start.col + range->size.col;
+	     loc.col++) {
+		void __iomem *va;
+		u32 val, nbitpos;
+
+		nbitpos = (loc.col - range->start.col) * (range->size.row - 1) + loc.row;
+
+		va = adev->base +
+		     aie_cal_regoff(adev, loc,
+				    AIEMLV2_SHIMPL_COLCLOCK_CTRL_REGOFF);
+		val = readl(va);
+
+		if (!((val & AIEMLV2_SHIMPL_COLCLOCK_CTRL_MASK) % 2))
+			continue;
+
+		aie_resource_set(&apart->cores_clk_state, nbitpos,
+				 range->size.row - 1);
+	}
+	/*
+	 * Set the tiles in use bitmap.
+	 * In case of scanning, tiles which are powered on are considered as
+	 * tiles in use.
+	 */
+	bitmap_copy(apart->tiles_inuse.bitmap, apart->cores_clk_state.bitmap,
+		    apart->tiles_inuse.total);
+
+	return 0;
+}
+
+static int aiemlv2_set_part_clocks(struct aie_partition *apart)
+{
+	struct aie_range *range = &apart->range;
+	struct aie_range prev_range = {};
+	struct aie_location loc;
+	int ret = -EINVAL;
+	u32 prev_ops = 0;
+
+	for (loc.col = 0; loc.col < range->size.col; loc.col++) {
+		u32 startbit, col_inuse = 0;
+
+		startbit = loc.col * (range->size.row - 1);
+
+		for (loc.row = range->start.row + 1;
+		     loc.row < range->start.row + range->size.row;
+		     loc.row++) {
+			u32 nbitpos = startbit + loc.row - 1;
+
+			if (aie_resource_testbit(&apart->tiles_inuse, nbitpos)) {
+				col_inuse = 1;
+				break;
+			}
+		}
+
+		if (col_inuse) {
+			struct aie_range op_range = {
+				.start.col = loc.col + range->start.col,
+				.size.col = 1,
+			};
+
+			ret = aie_resource_set(&apart->tiles_inuse, startbit,
+					       apart->range.size.row - 1);
+			if (ret)
+				return ret;
+			ret = aie_resource_set(&apart->cores_clk_state, startbit,
+					       apart->range.size.row - 1);
+			if (ret)
+				return ret;
+
+			if (!prev_ops) {
+				prev_range = op_range;
+				prev_ops = AIE_PART_INIT_OPT_ENB_COLCLK_BUFF;
+				continue;
+			}
+			if (prev_ops == AIE_PART_INIT_OPT_ENB_COLCLK_BUFF &&
+			    ((prev_range.start.col + prev_range.size.col) == op_range.start.col)) {
+				prev_range.size.col += op_range.size.col;
+				continue;
+			}
+			ret = aie_part_pm_ops(apart, NULL, prev_ops, prev_range, 0);
+			if (ret)
+				return ret;
+			prev_ops = AIE_PART_INIT_OPT_ENB_COLCLK_BUFF;
+			prev_range = op_range;
+		} else {
+			struct aie_range op_range = {
+				.start.col = loc.col + range->start.col,
+				.size.col = 1,
+			};
+
+			ret = aie_resource_clear(&apart->tiles_inuse, startbit,
+						 apart->range.size.row - 1);
+			if (ret)
+				return ret;
+			ret = aie_resource_clear(&apart->cores_clk_state, startbit,
+						 apart->range.size.row - 1);
+			if (ret)
+				return ret;
+			if (!prev_ops) {
+				prev_range = op_range;
+				prev_ops = AIE_PART_INIT_OPT_DIS_COLCLK_BUFF;
+				continue;
+			}
+			if (prev_ops == AIE_PART_INIT_OPT_DIS_COLCLK_BUFF &&
+			    ((prev_range.start.col + prev_range.size.col) == op_range.start.col)) {
+				prev_range.size.col += op_range.size.col;
+				continue;
+			}
+			ret = aie_part_pm_ops(apart, NULL, prev_ops, prev_range, 0);
+			if (ret)
+				return ret;
+			prev_ops = AIE_PART_INIT_OPT_DIS_COLCLK_BUFF;
+			prev_range = op_range;
+		}
+	}
+	if (prev_ops)
+		ret = aie_part_pm_ops(apart, NULL, prev_ops, prev_range, 0);
+	if (ret)
+		return ret;
+	return aie_part_pm_ops_flush(apart);
+}
+
 static const struct aie_tile_operations aiemlv2_ops = {
 	.get_tile_type = aiemlv2_get_tile_type,
+	.scan_part_clocks = aiemlv2_scan_part_clocks,
+	.set_part_clocks = aiemlv2_set_part_clocks,
 };
 
 /**
diff --git a/drivers/accel/amd-ai-engine/ai-engine-clock.c b/drivers/accel/amd-ai-engine/ai-engine-clock.c
new file mode 100644
index 000000000000..f2bf373c1da0
--- /dev/null
+++ b/drivers/accel/amd-ai-engine/ai-engine-clock.c
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * AMD AI Engine clock operations
+ *
+ * Copyright(C) 2026 Advanced Micro Devices, Inc. All rights reserved.
+ */
+
+#include <linux/amd-ai-engine.h>
+#include <linux/clk.h>
+#include <linux/firmware/xlnx-zynqmp.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+
+#include "ai-engine-internal.h"
+
+/**
+ * aie_part_init_clk_state() - initialize clock state and tiles in use bitmaps
+ * @apart: AI engine partition
+ *
+ * Return: error code for error 0 for success
+ */
+int aie_part_init_clk_state(struct aie_partition *apart)
+{
+	u32 num_tiles;
+	int ret;
+
+	/* SHIM row always enabled so it is not needed in the bitmap */
+	num_tiles = apart->range.size.col * (apart->range.size.row - 1);
+	ret = aie_resource_initialize(&apart->cores_clk_state, num_tiles);
+	if (ret) {
+		dev_err(&apart->dev, "failed to initialize clock state resource.\n");
+		return ret;
+	}
+
+	ret = aie_resource_initialize(&apart->tiles_inuse, num_tiles);
+	if (ret) {
+		dev_err(&apart->dev, "failed to initialize tiles in use resource.\n");
+		aie_resource_uninitialize(&apart->cores_clk_state);
+		return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * aie_part_get_clk_state_bit() - return bit position of the clock state of a
+ *				  tile
+ * @apart: AI engine partition
+ * @loc: AI engine tile location
+ *
+ * Return: bit position for success, negative value for failure
+ */
+static int aie_part_get_clk_state_bit(struct aie_partition *apart,
+				      struct aie_location *loc)
+{
+	u32 ttype = apart->adev->ops->get_tile_type(apart->adev, loc);
+
+	if (ttype != AIE_TILE_TYPE_TILE && ttype != AIE_TILE_TYPE_MEMORY)
+		return -EINVAL;
+
+	if (loc->col < apart->range.start.col)
+		return -EINVAL;
+
+	return (loc->col - apart->range.start.col) *
+	       (apart->range.size.row - 1) + loc->row - 1;
+}
+
+/**
+ * aie_part_scan_clk_state() - scan the clock states of tiles of the AI engine
+ *			       partition
+ * @apart: AI engine partition
+ *
+ * Return: 0 for success, negative value for failure.
+ *
+ * This function will scan the clock status of both the memory and core
+ * modules.
+ */
+int aie_part_scan_clk_state(struct aie_partition *apart)
+{
+	return apart->adev->ops->scan_part_clocks(apart);
+}
+
+/**
+ * aie_part_request_tiles() - request tiles from an AI engine partition.
+ * @apart: AI engine partition
+ * @num_tiles: number of tiles to request. If it is 0, it means all tiles
+ * @locs: the AI engine tiles locations array which will be requested
+ *
+ * Return: 0 for success, negative value for failure.
+ *
+ * This function will enable clocks of the specified tiles.
+ */
+int aie_part_request_tiles(struct aie_partition *apart, u32 num_tiles,
+			   struct aie_location *locs)
+{
+	int ret;
+
+	if (num_tiles == 0) {
+		aie_resource_set(&apart->tiles_inuse, 0,
+				 apart->tiles_inuse.total);
+	} else {
+		u32 n;
+
+		if (!locs)
+			return -EINVAL;
+
+		for (n = 0; n < num_tiles; n++) {
+			int bit = aie_part_get_clk_state_bit(apart, &locs[n]);
+
+			if (bit >= 0)
+				aie_resource_set(&apart->tiles_inuse, bit, 1);
+		}
+	}
+	ret = apart->adev->ops->set_part_clocks(apart);
+
+	return ret;
+}
+
+/**
+ * aie_part_release_tiles() - release tiles from an AI engine partition.
+ * @apart: AI engine partition
+ * @num_tiles: number of tiles to release. If it is 0, it means all tiles
+ * @locs: the AI engine tiles locations array which will be released
+ *
+ * Return: 0 for success, negative value for failure.
+ *
+ * This function will disable clocks of the specified tiles.
+ */
+int aie_part_release_tiles(struct aie_partition *apart, u32 num_tiles,
+			   struct aie_location *locs)
+{
+	int ret;
+
+	if (num_tiles == 0) {
+		aie_resource_clear(&apart->tiles_inuse, 0,
+				   apart->tiles_inuse.total);
+	} else {
+		u32 n;
+
+		if (!locs)
+			return -EINVAL;
+
+		for (n = 0; n < num_tiles; n++) {
+			int bit = aie_part_get_clk_state_bit(apart, &locs[n]);
+
+			if (bit >= 0)
+				aie_resource_clear(&apart->tiles_inuse, bit, 1);
+		}
+	}
+
+	ret = apart->adev->ops->set_part_clocks(apart);
+
+	return ret;
+}
diff --git a/drivers/accel/amd-ai-engine/ai-engine-internal.h b/drivers/accel/amd-ai-engine/ai-engine-internal.h
index d2857ec50033..572476c97aad 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-internal.h
+++ b/drivers/accel/amd-ai-engine/ai-engine-internal.h
@@ -37,11 +37,25 @@ struct aie_partition;
 /**
  * struct aie_tile_operations - AI engine device operations
  * @get_tile_type: get type of tile based on tile operation
+ * @scan_part_clocks: scan partition modules to check whether the modules are
+ *		      clock gated or not, and update the soft clock states
+ *		      structure. It is required to be called when the partition
+ *		      is requested so that the driver knows which modules are
+ *		      clock gated when the partition is requested. This function
+ *		      expects the caller to apply partition lock before calling
+ *		      this function.
+ * @set_part_clocks: set partition modules clocks gate registers based on the
+ *		     partition clock states bitmap. This function expects the
+ *		     caller to apply partition lock before calling this
+ *		     function. The caller function will need to set the bitmap
+ *		     on which tiles are required to be clocked on.
  * Different AI engine device version has its own device
  * operation.
  */
 struct aie_tile_operations {
 	u32 (*get_tile_type)(struct aie_device *adev, struct aie_location *loc);
+	int (*scan_part_clocks)(struct aie_partition *apart);
+	int (*set_part_clocks)(struct aie_partition *apart);
 };
 
 /**
@@ -275,6 +289,8 @@ struct aie_device {
  * @dev: AI Engine partition device
  * @adev: pointer to AI device instance
  * @range: range of partition
+ * @cores_clk_state: bitmap to indicate the power state of core and mem tiles
+ * @tiles_inuse: bitmap to indicate if a tile is in use
  * @mlock: protection for AI engine partition operations
  * @pm_ops: pm ops pkt and metadata for pm firmware calls
  */
@@ -283,6 +299,8 @@ struct aie_partition {
 	struct device dev;
 	struct aie_device *adev;
 	struct aie_range range;
+	struct aie_resource cores_clk_state;
+	struct aie_resource tiles_inuse;
 	struct mutex mlock;
 	struct aie_pm_ops pm_ops;
 };
@@ -307,10 +325,32 @@ struct aie_device_cfg {
 
 #define dev_to_aiepart(_dev) container_of((_dev), struct aie_partition, dev)
 
+/**
+ * aie_cal_regoff() - calculate register offset to the whole AI engine
+ *		      device start address
+ * @adev: AI engine device
+ * @loc: AI engine tile location
+ * @regoff_intile: register offset within a tile
+ *
+ * Return: register offset to the whole AI engine device start address
+ */
+static inline u32 aie_cal_regoff(struct aie_device *adev,
+				 struct aie_location loc, u32 regoff_intile)
+{
+	return regoff_intile + (loc.col << adev->col_shift) +
+	       (loc.row << adev->row_shift);
+}
+
 void aiemlv2_device_init(struct aie_device *adev);
 struct aie_partition *aie_part_create(struct aie_device *adev,
 				      u8 start_col, u8 num_col);
 void aie_part_release(struct aie_partition *apart);
+int aie_part_init_clk_state(struct aie_partition *apart);
+int aie_part_scan_clk_state(struct aie_partition *apart);
+int aie_part_request_tiles(struct aie_partition *apart, u32 num_tiles,
+			   struct aie_location *locs);
+int aie_part_release_tiles(struct aie_partition *apart, u32 num_tiles,
+			   struct aie_location *locs);
 int aie_resource_initialize(struct aie_resource *res, int count);
 void aie_resource_uninitialize(struct aie_resource *res);
 int aie_resource_check_region(struct aie_resource *res, u32 start,
@@ -318,6 +358,9 @@ int aie_resource_check_region(struct aie_resource *res, u32 start,
 int aie_resource_get_region(struct aie_resource *res, u32 start,
 			    u32 count);
 void aie_resource_put_region(struct aie_resource *res, int start, u32 count);
+int aie_resource_set(struct aie_resource *res, u32 start, u32 count);
+int aie_resource_clear(struct aie_resource *res, u32 start, u32 count);
+bool aie_resource_testbit(struct aie_resource *res, u32 bit);
 int aie_part_pm_ops_create(struct aie_partition *apart);
 void aie_part_pm_ops_destroy(struct aie_partition *apart);
 int aie_part_pm_ops_flush(struct aie_partition *apart);
diff --git a/drivers/accel/amd-ai-engine/ai-engine-part.c b/drivers/accel/amd-ai-engine/ai-engine-part.c
index 51580049f0e7..35451d1ed88a 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-part.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-part.c
@@ -26,6 +26,8 @@ void aie_part_release(struct aie_partition *apart)
 				apart->range.start.col -
 				adev->range.start.col,
 				apart->range.size.col);
+	aie_resource_uninitialize(&apart->cores_clk_state);
+	aie_resource_uninitialize(&apart->tiles_inuse);
 	device_unregister(&apart->dev);
 }
 
@@ -82,6 +84,22 @@ struct aie_partition *aie_part_create(struct aie_device *adev,
 		goto err;
 	}
 
+	ret = aie_part_init_clk_state(apart);
+	if (ret) {
+		dev_err(&apart->dev, "failed to initialize clock state\n");
+		aie_part_pm_ops_destroy(apart);
+		goto err;
+	}
+
+	ret = aie_part_scan_clk_state(apart);
+	if (ret) {
+		dev_err(&apart->dev, "failed to scan clock state.");
+		aie_part_pm_ops_destroy(apart);
+		aie_resource_uninitialize(&apart->cores_clk_state);
+		aie_resource_uninitialize(&apart->tiles_inuse);
+		goto err;
+	}
+
 	return apart;
 
 err:
diff --git a/drivers/accel/amd-ai-engine/ai-engine-res.c b/drivers/accel/amd-ai-engine/ai-engine-res.c
index 62df26edf87d..45b9447d896f 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-res.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-res.c
@@ -110,3 +110,59 @@ void aie_resource_put_region(struct aie_resource *res, int start, u32 count)
 		return;
 	bitmap_clear(res->bitmap, start, count);
 }
+
+/**
+ * aie_resource_set() - set the AI engine resource bits
+ * @res: pointer to AI engine resource
+ * @start: start bit to set
+ * @count: number of bits to set
+ *
+ * Return: 0 for success and negative value for failure
+ *
+ * This function sets the specified number bits in the resource.
+ */
+int aie_resource_set(struct aie_resource *res, u32 start, u32 count)
+{
+	if (!res || !res->bitmap || !count ||
+	    start > res->total || count > res->total - start)
+		return -EINVAL;
+
+	bitmap_set(res->bitmap, start, count);
+	return 0;
+}
+
+/**
+ * aie_resource_clear() - clear the AI engine resource bits
+ * @res: pointer to AI engine resource
+ * @start: start bit to set
+ * @count: number of bits to clear
+ *
+ * Return: 0 for success and negative value for failure
+ *
+ * This function clears the specified number bits in the resource.
+ */
+int aie_resource_clear(struct aie_resource *res, u32 start, u32 count)
+{
+	if (!res || !res->bitmap || !count ||
+	    start > res->total || count > res->total - start)
+		return -EINVAL;
+
+	bitmap_clear(res->bitmap, start, count);
+	return 0;
+}
+
+/**
+ * aie_resource_testbit() - test if a bit is set in a AI engine resource
+ * @res: pointer to AI engine resource
+ * @bit: bit to check
+ *
+ * Return: true for set, false for not set
+ */
+bool aie_resource_testbit(struct aie_resource *res, u32 bit)
+{
+	if (!res || !res->bitmap || bit >= res->total)
+		return false;
+
+	/* Locate the unsigned long the required bit belongs to */
+	return test_bit(bit, res->bitmap);
+}
diff --git a/include/linux/amd-ai-engine.h b/include/linux/amd-ai-engine.h
index 9df3463985af..229434372fc0 100644
--- a/include/linux/amd-ai-engine.h
+++ b/include/linux/amd-ai-engine.h
@@ -96,5 +96,4 @@ struct aie_op_handshake_data {
 
 struct device *aie_partition_request(struct device *dev, struct aie_partition_req *req);
 void aie_partition_release(struct device *dev);
-
 #endif
-- 
2.34.1


  parent reply	other threads:[~2026-11-18 23:32 UTC|newest]

Thread overview: 16+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18 23:31 [PATCH 00/15] accel: Add AMD Versal AI Engine driver (with Versal Gen 2 firmware support) Gregory Williams
2026-11-18 23:31 ` [PATCH 01/15] firmware: xilinx: Separate TF-A checking Gregory Williams
2026-11-18 23:31 ` [PATCH 02/15] firmware: xilinx: Call va_start after pm feature check Gregory Williams
2026-11-18 23:31 ` [PATCH 03/15] firmware: xilinx: Add comments about number of arguments Gregory Williams
2026-11-18 23:32 ` [PATCH 04/15] firmware: xilinx: Use match data for ZynqMP/Versal Gregory Williams
2026-11-18 23:32 ` [PATCH 05/15] firmware: xilinx: Rename zynqmp_pm_invoke_fw_fn() Gregory Williams
2026-11-18 23:32 ` [PATCH 06/15] dt-bindings: firmware: xilinx: Add Versal Gen 2 compatible string Gregory Williams
2026-11-18 23:32 ` [PATCH 07/15] firmware: xilinx: Add support for Versal Gen 2 Gregory Williams
2026-11-18 23:32 ` [PATCH 08/15] dt-bindings: clock: versal: add Versal Gen 2 compatible string Gregory Williams
2026-11-18 23:32 ` [PATCH 09/15] clk: zynqmp: Add " Gregory Williams
2026-11-18 23:32 ` [PATCH 10/15] drivers: firmware: xilinx: Add IOCTL support for the AIE run time operations Gregory Williams
2026-11-18 23:32 ` [PATCH 11/15] dt-bindings: soc: xilinx: Add Versal AI Engine DT binding Gregory Williams
2026-11-18 23:32 ` [PATCH 12/15] accel/amd-ai-engine: Add AMD AI Engine device driver Gregory Williams
2026-11-18 23:32 ` [PATCH 13/15] accel/amd-ai-engine: Add pm ops for firmware calls Gregory Williams
2026-11-18 23:32 ` Gregory Williams [this message]
2026-11-18 23:32 ` [PATCH 15/15] accel/amd-ai-engine: Add reset operations Gregory Williams

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=20261118233211.4121361-15-gregory.williams@amd.com \
    --to=gregory.williams@amd.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=ogabbay@kernel.org \
    /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®