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 15/15] accel/amd-ai-engine: Add reset operations
Date: Wed, 18 Nov 2026 15:32:11 -0800	[thread overview]
Message-ID: <20261118233211.4121361-16-gregory.williams@amd.com> (raw)
In-Reply-To: <20261118233211.4121361-1-gregory.williams@amd.com>

Add reset operations partition initialize/teardown.
aie_partition_initialize should be called before application start,
aie_partition_teardown should be called after application has finished.

Initialize will reset the device configuration, clear memories, enable
clocks of used tiles, configure hardware error reporting and NMUs, and
will enable ECC scrubbing.

Teardown will clear tile memories and disable tile clocks.

Signed-off-by: Gregory Williams <gregory.williams@amd.com>
---
 drivers/accel/amd-ai-engine/Makefile          |   3 +-
 .../accel/amd-ai-engine/ai-engine-aiemlv2.c   | 244 ++++++++++++++++++
 .../accel/amd-ai-engine/ai-engine-internal.h  |   8 +
 drivers/accel/amd-ai-engine/ai-engine-part.c  |  32 +++
 drivers/accel/amd-ai-engine/ai-engine-res.c   |  16 ++
 drivers/accel/amd-ai-engine/ai-engine-reset.c |  69 +++++
 include/linux/amd-ai-engine.h                 |  16 ++
 7 files changed, 387 insertions(+), 1 deletion(-)
 create mode 100644 drivers/accel/amd-ai-engine/ai-engine-reset.c

diff --git a/drivers/accel/amd-ai-engine/Makefile b/drivers/accel/amd-ai-engine/Makefile
index c6d090257d6e..d5b6ccde0a35 100644
--- a/drivers/accel/amd-ai-engine/Makefile
+++ b/drivers/accel/amd-ai-engine/Makefile
@@ -10,4 +10,5 @@ amd-aie-$(CONFIG_DRM_ACCEL_AMDAIE) := \
 	ai-engine-clock.o	\
 	ai-engine-part.o	\
 	ai-engine-pm.o		\
-	ai-engine-res.o
+	ai-engine-res.o		\
+	ai-engine-reset.o
diff --git a/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c b/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
index 26dd1d726bfa..910a9bda2305 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-aiemlv2.c
@@ -16,12 +16,16 @@
 /*
  * Register offsets
  */
+#define AIEMLV2_SHIMNOC_AXI_OUTSTANDING_TX_REGOFF	0x00002120U
 #define AIEMLV2_SHIMPL_COLCLOCK_CTRL_REGOFF		0x0007FF20U
+#define AIEMLV2_SHIMUC_AXI_OUTSTANDING_TX_REGOFF	0x000C0024U
 
 /*
  * Register masks
  */
+#define AIEMLV2_SHIMNOC_AXI_OUTSTANDING_TX_MASK		BIT(0)
 #define AIEMLV2_SHIMPL_COLCLOCK_CTRL_MASK		GENMASK(1, 0)
+#define AIEMLV2_SHIMUC_AXI_OUTSTANDING_TX_MASK		GENMASK(1, 0)
 
 static u32 aiemlv2_get_tile_type(struct aie_device *adev, struct aie_location *loc)
 {
@@ -173,10 +177,250 @@ static int aiemlv2_set_part_clocks(struct aie_partition *apart)
 	return aie_part_pm_ops_flush(apart);
 }
 
+static int aiemlv2_maskpoll_uc_outstanding_aximm_txn(struct aie_partition *apart)
+{
+	u32 end_col = apart->range.start.col + apart->range.size.col;
+	struct aie_location loc = {.row = 0};
+	int ret = 0;
+	u32 regoff;
+
+	for (loc.col = apart->range.start.col; loc.col < end_col; loc.col++) {
+		regoff = aie_cal_regoff(apart->adev, loc,
+					AIEMLV2_SHIMUC_AXI_OUTSTANDING_TX_REGOFF);
+		ret = aie_part_maskpoll_register(apart, regoff, 0x0,
+						 AIEMLV2_SHIMUC_AXI_OUTSTANDING_TX_MASK,
+						 2000000);
+		if (ret < 0) {
+			dev_err(&apart->dev,
+				"failed due to outstanding UC AXIMM transactions!\n");
+			return ret;
+		}
+	}
+
+	return 0;
+}
+
+static int aiemlv2_maskpoll_noc_outstanding_aximm_txn(struct aie_partition *apart)
+{
+	u32 end_col = apart->range.start.col + apart->range.size.col;
+	struct aie_location loc = {.row = 0};
+	int ret = 0;
+	u32 regoff;
+
+	for (loc.col = apart->range.start.col; loc.col < end_col; loc.col++) {
+		regoff = aie_cal_regoff(apart->adev, loc,
+					AIEMLV2_SHIMNOC_AXI_OUTSTANDING_TX_REGOFF);
+		ret = aie_part_maskpoll_register(apart, regoff, 0x0,
+						 AIEMLV2_SHIMNOC_AXI_OUTSTANDING_TX_MASK,
+						 2000000);
+		if (ret < 0) {
+			dev_err(&apart->dev,
+				"failed due to outstanding NoC AXIMM transactions!\n");
+			return ret;
+		}
+	}
+
+	return 0;
+}
+
+static int aiemlv2_part_init(struct aie_partition *apart,
+			     struct aie_partition_init_args *args)
+{
+	u32 opts;
+	int ret;
+
+	mutex_lock(&apart->mlock);
+	opts = AIE_PART_INIT_OPT_ENB_UC_DMA_PAUSE | AIE_PART_INIT_OPT_ENB_NOC_DMA_PAUSE;
+	ret = aie_part_pm_ops(apart, NULL, opts, apart->range, 1);
+	if (ret)
+		goto out;
+
+	ret = aiemlv2_maskpoll_noc_outstanding_aximm_txn(apart);
+	if (ret)
+		goto out;
+
+	ret = aiemlv2_maskpoll_uc_outstanding_aximm_txn(apart);
+	if (ret)
+		goto out;
+
+	aie_resource_clear_all(&apart->tiles_inuse);
+	aie_resource_clear_all(&apart->cores_clk_state);
+
+	/* First lets send non-data aie_op_type_len ops */
+	opts = 0;
+	/* This operation will do first 4 steps of sequence */
+	opts |= (args->init_opts & AIE_PART_INIT_OPT_COLUMN_RST);
+	opts |= (args->init_opts & AIE_PART_INIT_OPT_SHIM_RST);
+	opts |= (args->init_opts & AIE_PART_INIT_OPT_BLOCK_NOCAXIMMERR);
+	opts |= (args->init_opts & AIE_PART_INIT_OPT_ENB_COLCLK_BUFF);
+
+	/*
+	 * push opts to pm and flush, these ops need to be completed before we
+	 * call the next ones
+	 */
+	ret = aie_part_pm_ops(apart, NULL, opts, apart->range, 1);
+	if (ret) {
+		dev_err(&apart->dev, "pm ops: 0x%x failed: %d\n", opts, ret);
+		goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_ZEROIZEMEM) {
+		opts |= AIE_PART_INIT_OPT_ZEROIZEMEM;
+		ret = aie_part_pm_ops(apart, NULL, AIE_PART_INIT_OPT_ZEROIZEMEM,
+				      apart->range, 1);
+		if (ret)
+			goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_UC_ZEROIZATION) {
+		u16 data = 0x6;
+
+		opts |= AIE_PART_INIT_OPT_UC_ZEROIZATION;
+		ret = aie_part_pm_ops(apart, &data, AIE_PART_INIT_OPT_UC_ZEROIZATION,
+				      apart->range, 1);
+		if (ret)
+			goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_NMU_CONFIG) {
+		struct aie_range range = {0};
+
+		opts |= AIE_PART_INIT_OPT_NMU_CONFIG;
+		if (apart->range.start.col == 0) {
+			range.size.col = 2;
+			ret = aie_part_pm_ops(apart, NULL, AIE_PART_INIT_OPT_NMU_CONFIG,
+					      range, 0);
+			if (ret)
+				goto out;
+		}
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_HW_ERR_INT) {
+		u16 data = 0;
+
+		opts |= AIE_PART_INIT_OPT_HW_ERR_INT;
+		ret = aie_part_pm_ops(apart, &data, AIE_PART_INIT_OPT_HW_ERR_INT,
+				      apart->range, 0);
+		if (ret)
+			goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_HW_ERR_MASK) {
+		u16 data = 0x2;
+
+		opts |= AIE_PART_INIT_OPT_HW_ERR_MASK;
+		ret = aie_part_pm_ops(apart, &data, AIE_PART_INIT_OPT_HW_ERR_MASK,
+				      apart->range, 0);
+		if (ret)
+			goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_SET_ECC_SCRUB_PERIOD) {
+		u16 data;
+
+		if (args->ecc_scrub > U16_MAX) {
+			ret = -EINVAL;
+			goto out;
+		}
+
+		data = args->ecc_scrub;
+		opts |= AIE_PART_INIT_OPT_SET_ECC_SCRUB_PERIOD;
+		ret = aie_part_pm_ops(apart, &data,
+				      AIE_PART_INIT_OPT_SET_ECC_SCRUB_PERIOD,
+				      apart->range, 0);
+		if (ret)
+			goto out;
+	}
+
+	if (args->init_opts & AIE_PART_INIT_OPT_UC_ENB_MEM_PRIV) {
+		opts |= AIE_PART_INIT_OPT_UC_ENB_MEM_PRIV;
+
+		ret = aie_part_pm_ops(apart, NULL, AIE_PART_INIT_OPT_UC_ENB_MEM_PRIV,
+				      apart->range, 0);
+		if (ret)
+			goto out;
+	}
+
+	/* Request tile locations */
+	ret = aie_part_request_tiles(apart, args->num_tiles, args->locs);
+	if (ret)
+		goto out;
+
+	if (args->init_opts & AIE_PART_INIT_OPT_DIS_TLAST_ERROR) {
+		u16 data = 0;
+
+		opts |= AIE_PART_INIT_OPT_DIS_TLAST_ERROR;
+		ret = aie_part_pm_ops(apart, &data,
+				      AIE_PART_INIT_OPT_DIS_TLAST_ERROR,
+				      apart->range, 1);
+		if (ret)
+			goto out;
+	}
+
+	if (opts != args->init_opts)
+		dev_warn(&apart->dev, "Invalid init_opts: 0x%x\n", opts ^ args->init_opts);
+
+out:
+	mutex_unlock(&apart->mlock);
+	return ret;
+}
+
+static int aiemlv2_part_teardown(struct aie_partition *apart)
+{
+	u32 opts;
+	u16 data;
+	int ret;
+
+	mutex_lock(&apart->mlock);
+
+	opts = AIE_PART_INIT_OPT_ENB_UC_DMA_PAUSE | AIE_PART_INIT_OPT_ENB_NOC_DMA_PAUSE;
+	ret = aie_part_pm_ops(apart, NULL, opts, apart->range, 1);
+	if (ret)
+		goto out;
+
+	ret = aiemlv2_maskpoll_noc_outstanding_aximm_txn(apart);
+	if (ret)
+		goto out;
+
+	ret = aiemlv2_maskpoll_uc_outstanding_aximm_txn(apart);
+	if (ret)
+		goto out;
+
+	opts = AIE_PART_INIT_OPT_COLUMN_RST |
+	       AIE_PART_INIT_OPT_SHIM_RST |
+	       AIE_PART_INIT_OPT_ZEROIZEMEM;
+	ret = aie_part_pm_ops(apart, NULL, opts, apart->range, 0);
+	if (ret)
+		goto out;
+
+	/* Zeroizes the uc-DM and uc shared DM */
+	data = 0x6;
+	ret = aie_part_pm_ops(apart, &data, AIE_PART_INIT_OPT_UC_ZEROIZATION, apart->range, 1);
+	if (ret)
+		goto out;
+	ret = aie_part_pm_ops(apart, NULL, AIE_PART_INIT_OPT_DIS_COLCLK_BUFF, apart->range, 0);
+	if (ret)
+		goto out;
+	ret = aie_part_pm_ops_flush(apart);
+	if (ret)
+		goto out;
+
+	/* Clear resources */
+	aie_resource_clear_all(&apart->tiles_inuse);
+	aie_resource_clear_all(&apart->cores_clk_state);
+
+out:
+	mutex_unlock(&apart->mlock);
+
+	return ret;
+}
+
 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,
+	.part_init = aiemlv2_part_init,
+	.part_teardown = aiemlv2_part_teardown,
 };
 
 /**
diff --git a/drivers/accel/amd-ai-engine/ai-engine-internal.h b/drivers/accel/amd-ai-engine/ai-engine-internal.h
index 572476c97aad..64691223ff9c 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-internal.h
+++ b/drivers/accel/amd-ai-engine/ai-engine-internal.h
@@ -49,6 +49,8 @@ struct aie_partition;
  *		     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.
+ * @part_init: initialize partition with user options.
+ * @part_teardown: teardown partition
  * Different AI engine device version has its own device
  * operation.
  */
@@ -56,6 +58,9 @@ 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);
+	int (*part_init)(struct aie_partition *apart,
+			 struct aie_partition_init_args *args);
+	int (*part_teardown)(struct aie_partition *apart);
 };
 
 /**
@@ -360,10 +365,13 @@ int aie_resource_get_region(struct aie_resource *res, u32 start,
 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);
+int aie_resource_clear_all(struct aie_resource *res);
 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);
 int aie_part_pm_ops(struct aie_partition *apart, void *data, u32 type,
 		    struct aie_range range, bool flush);
+int aie_part_maskpoll_register(struct aie_partition *apart, u32 offset, u32 data,
+			       u32 mask, u32 timeout);
 #endif /* AIE_INTERNAL_H */
diff --git a/drivers/accel/amd-ai-engine/ai-engine-part.c b/drivers/accel/amd-ai-engine/ai-engine-part.c
index 35451d1ed88a..2cd93c02246e 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-part.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-part.c
@@ -6,6 +6,7 @@
  */
 
 #include <linux/amd-ai-engine.h>
+#include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
@@ -106,3 +107,34 @@ struct aie_partition *aie_part_create(struct aie_device *adev,
 	device_unregister(&apart->dev);
 	return ERR_PTR(ret);
 }
+
+/**
+ * aie_part_maskpoll_register() - Mask polls an address for a data in a partition.
+ * @apart: AI engine partition.
+ * @offset: AI engine register offset.
+ * @data: data to poll.
+ * @mask: if it is non 0, it is mask read.
+ * @timeout: Timeout in microseconds.
+ *
+ * Return: zero for success, or -EBUSY for failure
+ */
+int aie_part_maskpoll_register(struct aie_partition *apart, u32 offset, u32 data,
+			       u32 mask, u32 timeout)
+{
+	u32 usleep_time = 10;
+	u32 value;
+	u32 i;
+
+	for (i = 0; i < timeout; i += usleep_time) {
+		value = readl(apart->adev->base + offset);
+		if ((value & mask) == data)
+			return 0;
+		usleep_range(usleep_time, usleep_time + 10);
+	}
+
+	value = readl(apart->adev->base + offset);
+	if ((value & mask) == data)
+		return 0;
+
+	return -EBUSY;
+}
diff --git a/drivers/accel/amd-ai-engine/ai-engine-res.c b/drivers/accel/amd-ai-engine/ai-engine-res.c
index 45b9447d896f..d35c27141cdd 100644
--- a/drivers/accel/amd-ai-engine/ai-engine-res.c
+++ b/drivers/accel/amd-ai-engine/ai-engine-res.c
@@ -151,6 +151,22 @@ int aie_resource_clear(struct aie_resource *res, u32 start, u32 count)
 	return 0;
 }
 
+/**
+ * aie_resource_clear_all() - clear all the AI engine resource bits
+ * @res: pointer to AI engine resource
+ * @return: 0 for success and negative value for failure
+ *
+ * This function clears all the bits in the resource.
+ */
+int aie_resource_clear_all(struct aie_resource *res)
+{
+	if (!res || !res->bitmap)
+		return -EINVAL;
+
+	bitmap_clear(res->bitmap, 0, res->total);
+	return 0;
+}
+
 /**
  * aie_resource_testbit() - test if a bit is set in a AI engine resource
  * @res: pointer to AI engine resource
diff --git a/drivers/accel/amd-ai-engine/ai-engine-reset.c b/drivers/accel/amd-ai-engine/ai-engine-reset.c
new file mode 100644
index 000000000000..f34d8d687d0e
--- /dev/null
+++ b/drivers/accel/amd-ai-engine/ai-engine-reset.c
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * AMD AI Engine device driver reset implementation
+ *
+ * Copyright (C) 2025 Advanced Micro Devices, Inc.
+ */
+
+#include <linux/amd-ai-engine.h>
+#include <linux/firmware/xlnx-zynqmp.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+
+#include "ai-engine-internal.h"
+
+/**
+ * aie_partition_initialize() - AI engine partition initialization
+ * @dev: AI engine partition device
+ * @args: User initialization options
+ *
+ * Return: 0 for success and negative value for failure
+ *
+ * Based on user passed options this function will:
+ * - enable column and shim reset
+ * - ungate all columns
+ * - disable column reset
+ * - zeroize memories
+ * - setup NMU traffic and hardware error reporting
+ */
+int aie_partition_initialize(struct device *dev,
+			     struct aie_partition_init_args *args)
+{
+	struct aie_partition *apart;
+
+	if (!dev || !args)
+		return -EINVAL;
+
+	apart = dev_to_aiepart(dev);
+	if (apart->adev->ops->part_init)
+		return apart->adev->ops->part_init(apart, args);
+
+	return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(aie_partition_initialize);
+
+/**
+ * aie_partition_teardown() - AI engine partition teardown
+ * @dev: AI engine partition device
+ *
+ * Return: 0 for success and negative value for failure
+ *
+ * This function will:
+ * - reset columns and shim
+ * - zeroize memories
+ * - gate all columns
+ */
+int aie_partition_teardown(struct device *dev)
+{
+	struct aie_partition *apart;
+
+	if (!dev)
+		return -EINVAL;
+
+	apart = dev_to_aiepart(dev);
+	if (apart->adev->ops->part_teardown)
+		return apart->adev->ops->part_teardown(apart);
+
+	return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(aie_partition_teardown);
diff --git a/include/linux/amd-ai-engine.h b/include/linux/amd-ai-engine.h
index 229434372fc0..95884b782742 100644
--- a/include/linux/amd-ai-engine.h
+++ b/include/linux/amd-ai-engine.h
@@ -94,6 +94,22 @@ struct aie_op_handshake_data {
 	struct aie_location loc;
 };
 
+/*
+ * struct aie_partition_init_args - AIE partition initialization arguments
+ * @locs: Allocated array of tile locations that will be used
+ * @num_tiles: Number of tiles to use
+ * @init_opts: Partition initialization options
+ * @ecc_scrub: ecc_scrub period.
+ */
+struct aie_partition_init_args {
+	struct aie_location *locs;
+	u32 num_tiles;
+	u32 init_opts;
+	u32 ecc_scrub;
+};
+
 struct device *aie_partition_request(struct device *dev, struct aie_partition_req *req);
 void aie_partition_release(struct device *dev);
+int aie_partition_initialize(struct device *dev, struct aie_partition_init_args *args);
+int aie_partition_teardown(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 ` [PATCH 14/15] accel/amd-ai-engine: Add support to enable/disable tile clocks Gregory Williams
2026-11-18 23:32 ` Gregory Williams [this message]

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-16-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®