mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Frank Li <Frank.li@oss.nxp.com>
To: Linus Walleij <linusw@kernel.org>
Cc: Vinod Koul <vkoul@kernel.org>, Frank Li <Frank.Li@kernel.org>,
	linux-arm-kernel@lists.infradead.org, dmaengine@vger.kernel.org,
	linux-kernel@vger.kernel.org, Ulf Hansson <ulfh@kernel.org>,
	linux-pm@vger.kernel.org
Subject: Re: [PATCH] dmaengine: ste_dma40: Use power domain for LCLA SRAM
Date: Wed, 18 Nov 2026 13:53:10 -0600	[thread overview]
Message-ID: <av4CJkri6LQO9FxG@SMW015318> (raw)
In-Reply-To: <20261115-ux500-dma40-powerdomain-v1-1-da8b6e1a0376@kernel.org>

On Sun, Nov 15, 2026 at 10:26:27PM +0100, Linus Walleij wrote:
> Replace the LCLA ESRAM regulator with runtime PM of the SRAM device
> owning the ESRAM34 power domain.
>
> Use the existing LCLA SRAM phandle instead of the never-set
> use_esram_lcla flag and the obsolete named memory resource.
> The bool indicating if we use LCLA SRAM seems pointless, let's just
> check if it's NULL or not. Simpler.
>
> Acquire the SRAM runtime PM reference when allocating a DMA channel,
> before taking its spinlock, and release it when the channel is freed.
> Descriptor preparation can run under a client's spinlock, so it cannot
> synchronously resume the SRAM.
>
> Acquiring a handle to the SRAM can fail and then we defer probe.
>
> Since we can defer probe(), probe() and friends can't be tagged as
> __init anymore, and it's better like this anyway.
>
> Keep a stateless device link for system-sleep ordering without adding
> a runtime PM dependency to the IRQ-safe DMA controller.
>
> Suggested-by: Frank Li <Frank.li@oss.nxp.com>
> Signed-off-by: Linus Walleij <linusw@kernel.org>
> ---
> The Ux500 genpd prerequisites have been merged into the powerdomain tree.
> Probably the fix sent earlier should be merged first:
> "dmaengine: ste_dma40: Keep prepared descriptors across termination"
>
> The SRAM driver will be patched separately.
> ---
>  drivers/dma/ste_dma40.c | 253 +++++++++++++++++++++++++++---------------------
>  1 file changed, 142 insertions(+), 111 deletions(-)
>
> diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
> index f1cbc719c4f0..eca1ae95fe1c 100644
> --- a/drivers/dma/ste_dma40.c
> +++ b/drivers/dma/ste_dma40.c
> @@ -21,8 +21,8 @@
>  #include <linux/of.h>
>  #include <linux/of_address.h>
>  #include <linux/of_dma.h>
> +#include <linux/of_platform.h>
>  #include <linux/amba/bus.h>
> -#include <linux/regulator/consumer.h>
>
>  #include "dmaengine.h"
>  #include "ste_dma40.h"
> @@ -41,7 +41,6 @@
>   * certain use cases.
>   * @num_of_soft_lli_chans: The number of channels that needs to be configured
>   * to use SoftLLI.
> - * @use_esram_lcla: flag for mapping the lcla into esram region
>   * @num_of_memcpy_chans: The number of channels reserved for memcpy.
>   * @memcpy_channels: The event lines used for memcpy.
>   * @num_of_phy_chans: The number of physical channels implemented in HW.
> @@ -52,7 +51,6 @@ struct stedma40_platform_data {
>  	int				 disabled_channels[STEDMA40_MAX_PHYS];
>  	int				*soft_lli_chans;
>  	int				 num_of_soft_lli_chans;
> -	bool				 use_esram_lcla;
>  	int				 num_of_memcpy_chans;
>  	u32				 memcpy_channels[D40_MEMCPY_MAX_CHANS];
>  	int				 num_of_phy_chans;
> @@ -301,7 +299,7 @@ struct d40_reg_val {
>  	unsigned int val;
>  };
>
> -static __initdata struct d40_reg_val dma_init_reg_v4a[] = {
> +static struct d40_reg_val dma_init_reg_v4a[] = {
>  	/* Clock every part of the DMA block from start */
>  	{ .reg = D40_DREG_GCC,    .val = D40_DREG_GCC_ENABLE_ALL},
>
> @@ -319,7 +317,8 @@ static __initdata struct d40_reg_val dma_init_reg_v4a[] = {
>  	{ .reg = D40_DREG_LCTIS2, .val = 0xFFFFFFFF},
>  	{ .reg = D40_DREG_LCTIS3, .val = 0xFFFFFFFF}
>  };
> -static __initdata struct d40_reg_val dma_init_reg_v4b[] = {
> +
> +static struct d40_reg_val dma_init_reg_v4b[] = {
>  	/* Clock every part of the DMA block from start */
>  	{ .reg = D40_DREG_GCC,    .val = D40_DREG_GCC_ENABLE_ALL},
>
> @@ -413,6 +412,7 @@ struct d40_desc {
>   * struct d40_lcla_pool - LCLA pool settings and data.
>   *
>   * @base: The virtual address of LCLA. 18 bit aligned.
> + * @esram: I/O mapping when LCLA resides in SRAM instead of system memory.
>   * @dma_addr: DMA address, if mapped
>   * @base_unaligned: The original kmalloc pointer, if kmalloc is used.
>   * This pointer is only there for clean-up on error.
> @@ -423,6 +423,7 @@ struct d40_desc {
>   */
>  struct d40_lcla_pool {
>  	void		*base;
> +	void __iomem	*esram;
>  	dma_addr_t	dma_addr;
>  	void		*base_unaligned;
>  	unsigned int	 alloc_order;
> @@ -578,7 +579,8 @@ struct d40_gen_dmac {
>   * to phy_chans entries.
>   * @plat_data: Pointer to provided platform_data which is the driver
>   * configuration.
> - * @lcpa_regulator: Pointer to hold the regulator for the esram bank for lcla.
> + * @lcla_dev: SRAM device for the ESRAM bank used by LCLA.
> + * @lcla_link: Device link to keep system PM ordered against LCLA.
>   * @phy_res: Vector containing all physical channels.
>   * @lcla_pool: lcla pool settings and data.
>   * @lcpa_base: The virtual mapped address of LCPA.
> @@ -613,7 +615,8 @@ struct d40_base {
>  	struct d40_chan			**lookup_log_chans;
>  	struct d40_chan			**lookup_phy_chans;
>  	struct stedma40_platform_data	 *plat_data;
> -	struct regulator		 *lcpa_regulator;
> +	struct device			 *lcla_dev;
> +	struct device_link		 *lcla_link;
>  	/* Physical half channels */
>  	struct d40_phy_res		 *phy_res;
>  	struct d40_lcla_pool		  lcla_pool;
> @@ -630,6 +633,25 @@ struct d40_base {
>  	struct d40_chan			 phy_chans[];
>  };
>
> +static int d40_lcla_runtime_get(struct d40_base *base)
> +{
> +	if (!base->lcla_dev)
> +		return 0;
> +
> +	return pm_runtime_resume_and_get(base->lcla_dev);
> +}
> +
> +static void d40_lcla_runtime_put(struct d40_base *base)
> +{
> +	if (base->lcla_dev)
> +		pm_runtime_put(base->lcla_dev);
> +}
> +
> +static void d40_transfer_runtime_put(struct d40_base *base)
> +{
> +	pm_runtime_put_autosuspend(base->dev);
> +}
> +
>  static bool chan_is_physical(struct d40_chan *chan)
>  {
>  	return chan->log_num == D40_PHY_CHAN;
> @@ -859,7 +881,6 @@ static void d40_log_lli_to_lcxa(struct d40_chan *chan, struct d40_desc *desc)
>  	bool cyclic = desc->cyclic;
>  	int curr_lcla = -EINVAL;
>  	int first_lcla = 0;
> -	bool use_esram_lcla = chan->base->plat_data->use_esram_lcla;
>  	bool linkback;
>
>  	/*
> @@ -912,7 +933,6 @@ static void d40_log_lli_to_lcxa(struct d40_chan *chan, struct d40_desc *desc)
>  	for (; lli_current < lli_len; lli_current++) {
>  		unsigned int lcla_offset = chan->phy_chan->num * 1024 +
>  					   8 * curr_lcla * 2;
> -		struct d40_log_lli *lcla = pool->base + lcla_offset;
>  		unsigned int flags = 0;
>  		int next_lcla;
>
> @@ -936,16 +956,17 @@ static void d40_log_lli_to_lcxa(struct d40_chan *chan, struct d40_desc *desc)
>  		 * One unused LCLA in the cyclic case if the very first
>  		 * next_lcla fails...
>  		 */
> -		d40_log_lli_lcla_write(lcla,
> -				       &lli->dst[lli_current],
> -				       &lli->src[lli_current],
> -				       next_lcla, flags);
> -
> -		/*
> -		 * Cache maintenance is not needed if lcla is
> -		 * mapped in esram
> -		 */
> -		if (!use_esram_lcla) {
> +		if (pool->esram) {
> +			/* LCPA and LCLA use the same four-word SRAM layout. */
> +			d40_log_lli_lcpa_write(pool->esram + lcla_offset,
> +					       &lli->dst[lli_current],
> +					       &lli->src[lli_current],
> +					       next_lcla, flags);
> +		} else {
> +			d40_log_lli_lcla_write(pool->base + lcla_offset,
> +					       &lli->dst[lli_current],
> +					       &lli->src[lli_current],
> +					       next_lcla, flags);
>  			dma_sync_single_range_for_device(chan->base->dev,
>  						pool->dma_addr, lcla_offset,
>  						2 * sizeof(struct d40_log_lli),
> @@ -1661,7 +1682,7 @@ static struct d40_desc *d40_queue_start(struct d40_chan *d40c)
>  			d40_desc_done(d40c, d40d);
>  			d40c->pending_tx++;
>  			d40c->busy = false;
> -			pm_runtime_put_autosuspend(d40c->base->dev);
> +			d40_transfer_runtime_put(d40c->base);
>  			tasklet_schedule(&d40c->tasklet);
>  			return ERR_PTR(err);
>  		}
> @@ -1717,7 +1738,7 @@ static void dma_tc_handle(struct d40_chan *d40c)
>  		if (d40_queue_start(d40c) == NULL) {
>  			d40c->busy = false;
>
> -			pm_runtime_put_autosuspend(d40c->base->dev);
> +			d40_transfer_runtime_put(d40c->base);
>  		}
>  	}
>
> @@ -2270,7 +2291,7 @@ static int d40_free_dma(struct d40_chan *d40c)
>  		d40c->base->lookup_phy_chans[phy->num] = NULL;
>
>  	if (d40c->busy)
> -		pm_runtime_put_autosuspend(d40c->base->dev);
> +		d40_transfer_runtime_put(d40c->base);
>
>  	d40c->busy = false;
>  	d40c->phy_chan = NULL;
> @@ -2646,6 +2667,12 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
>  	struct d40_chan *d40c =
>  		container_of(chan, struct d40_chan, chan);
>  	bool is_free_phy;
> +
> +	/* Preparation and submission may run with the client's spinlock held. */
> +	err = d40_lcla_runtime_get(d40c->base);
> +	if (err < 0)
> +		return err;
> +
>  	spin_lock_irqsave(&d40c->lock, flags);
>
>  	dma_cookie_init(chan);
> @@ -2703,6 +2730,8 @@ static int d40_alloc_chan_resources(struct dma_chan *chan)
>  	pm_runtime_put_autosuspend(d40c->base->dev);
>   unlock:
>  	spin_unlock_irqrestore(&d40c->lock, flags);
> +	if (err < 0)
> +		d40_lcla_runtime_put(d40c->base);
>  	return err;
>  }
>
> @@ -2725,6 +2754,10 @@ static void d40_free_chan_resources(struct dma_chan *chan)
>  	if (err)
>  		chan_err(d40c, "Failed to free channel\n");
>  	spin_unlock_irqrestore(&d40c->lock, flags);
> +
> +	/* Keep SRAM powered if stopping the channel failed. */
> +	if (!d40c->phy_chan)
> +		d40_lcla_runtime_put(d40c->base);
>  }
>
>  static struct dma_async_tx_descriptor *d40_prep_memcpy(struct dma_chan *chan,
> @@ -2877,7 +2910,7 @@ static int d40_terminate_all(struct dma_chan *chan)
>  	 */
>  	d40_term_all(d40c);
>  	if (d40c->busy)
> -		pm_runtime_put_autosuspend(d40c->base->dev);
> +		d40_transfer_runtime_put(d40c->base);
>  	d40c->busy = false;
>
>  	spin_unlock_irqrestore(&d40c->lock, flags);
> @@ -3047,9 +3080,9 @@ static int d40_set_runtime_config_write(struct dma_chan *chan,
>
>  /* Initialization functions */
>
> -static void __init d40_chan_init(struct d40_base *base, struct dma_device *dma,
> -				 struct d40_chan *chans, int offset,
> -				 int num_chans)
> +static void d40_chan_init(struct d40_base *base, struct dma_device *dma,
> +			  struct d40_chan *chans, int offset,
> +			  int num_chans)
>  {
>  	int i = 0;
>  	struct d40_chan *d40c;
> @@ -3123,8 +3156,8 @@ static void d40_ops_init(struct d40_base *base, struct dma_device *dev)
>  	dev->dev = base->dev;
>  }
>
> -static int __init d40_dmaengine_init(struct d40_base *base,
> -				     int num_reserved_chans)
> +static int d40_dmaengine_init(struct d40_base *base,
> +			      int num_reserved_chans)
>  {
>  	int err ;
>
> @@ -3201,29 +3234,11 @@ static int __init d40_dmaengine_init(struct d40_base *base,
>  #ifdef CONFIG_PM_SLEEP
>  static int dma40_suspend(struct device *dev)
>  {
> -	struct d40_base *base = dev_get_drvdata(dev);
> -	int ret;
> -
> -	ret = pm_runtime_force_suspend(dev);
> -	if (ret)
> -		return ret;
> -
> -	if (base->lcpa_regulator)
> -		ret = regulator_disable(base->lcpa_regulator);
> -	return ret;
> +	return pm_runtime_force_suspend(dev);
>  }
>
>  static int dma40_resume(struct device *dev)
>  {
> -	struct d40_base *base = dev_get_drvdata(dev);
> -	int ret = 0;
> -
> -	if (base->lcpa_regulator) {
> -		ret = regulator_enable(base->lcpa_regulator);
> -		if (ret)
> -			return ret;
> -	}
> -
>  	return pm_runtime_force_resume(dev);
>  }
>  #endif
> @@ -3313,7 +3328,7 @@ static const struct dev_pm_ops dma40_pm_ops = {
>
>  /* Initialization functions. */
>
> -static int __init d40_phy_res_init(struct d40_base *base)
> +static int d40_phy_res_init(struct d40_base *base)
>  {
>  	int i;
>  	int num_phy_chans_avail = 0;
> @@ -3405,8 +3420,8 @@ static void d40_drop_kmem_cache_action(void *d)
>  	kmem_cache_destroy(desc_slab);
>  }
>
> -static int __init d40_hw_detect_init(struct platform_device *pdev,
> -				     struct d40_base **retbase)
> +static int d40_hw_detect_init(struct platform_device *pdev,
> +			      struct d40_base **retbase)
>  {
>  	struct stedma40_platform_data *plat_data = dev_get_platdata(&pdev->dev);
>  	struct device *dev = &pdev->dev;
> @@ -3592,7 +3607,7 @@ static int __init d40_hw_detect_init(struct platform_device *pdev,
>  	return 0;
>  }
>
> -static void __init d40_hw_init(struct d40_base *base)
> +static void d40_hw_init(struct d40_base *base)
>  {
>
>  	int i;
> @@ -3640,13 +3655,9 @@ static void __init d40_hw_init(struct d40_base *base)
>
>  	/* Write which interrupt to clear */
>  	writel(pcicr, base->virtbase + base->gen_dmac.interrupt_clear);
> -
> -	/* These are __initdata and cannot be accessed after init */
> -	base->gen_dmac.init_reg = NULL;
> -	base->gen_dmac.init_reg_size = 0;
>  }
>
> -static int __init d40_lcla_allocate(struct d40_base *base)
> +static int d40_lcla_allocate(struct d40_base *base)
>  {
>  	struct d40_lcla_pool *pool = &base->lcla_pool;
>  	size_t lcla_size = SZ_1K * base->num_phy_chans;
> @@ -3728,8 +3739,7 @@ static int __init d40_lcla_allocate(struct d40_base *base)
>  	return ret;
>  }
>
> -static int __init d40_of_probe(struct device *dev,
> -			       struct device_node *np)
> +static int d40_of_probe(struct device *dev, struct device_node *np)
>  {
>  	struct stedma40_platform_data *pdata;
>  	int num_phy = 0, num_memcpy = 0, num_disabled = 0;
> @@ -3781,13 +3791,70 @@ static int __init d40_of_probe(struct device *dev,
>  	return 0;
>  }
>
> -static int __init d40_probe(struct platform_device *pdev)
> +static int d40_lcla_sram_setup(struct d40_base *base)
> +{
> +	struct device *dev = base->dev;
> +	struct device_node *np, *parent;
> +	struct platform_device *sram;
> +	struct resource res;
> +	bool ready;
> +	int ret;
> +
> +	np = of_parse_phandle(dev->of_node, "sram", 1);
> +	if (!np)
> +		return 0;
> +
> +	ret = of_address_to_resource(np, 0, &res);
> +	parent = of_get_parent(np);
> +	of_node_put(np);
> +	if (ret) {
> +		of_node_put(parent);
> +		return ret;
> +	}
> +	if (!parent)
> +		return -EINVAL;
> +
> +	if (!IS_ALIGNED(res.start, LCLA_ALIGNMENT) ||
> +	    resource_size(&res) < SZ_1K * base->num_phy_chans ||
> +	    res.end > U32_MAX) {
> +		of_node_put(parent);
> +		return dev_err_probe(dev, -EINVAL, "Invalid LCLA SRAM region\n");
> +	}
> +
> +	sram = of_find_device_by_node(parent);
> +	of_node_put(parent);
> +	if (!sram)
> +		return -EPROBE_DEFER;
> +	base->lcla_dev = &sram->dev;
> +
> +	device_lock(base->lcla_dev);
> +	ready = device_is_bound(base->lcla_dev);
> +	device_unlock(base->lcla_dev);
> +	if (!ready)
> +		return -EPROBE_DEFER;
> +
> +	base->lcla_link = device_link_add(dev, base->lcla_dev,
> +					  DL_FLAG_STATELESS);
> +	if (!base->lcla_link)
> +		return -ENOMEM;
> +
> +	/* The SRAM driver owns the containing region. */
> +	base->lcla_pool.esram = devm_ioremap(dev, res.start, resource_size(&res));
> +	if (!base->lcla_pool.esram)
> +		return -ENOMEM;
> +
> +	writel(res.start, base->virtbase + D40_DREG_LCLA);
> +	dev_info(dev, "using LCLA SRAM at %pa\n", &res.start);
> +
> +	return 0;
> +}
> +
> +static int d40_probe(struct platform_device *pdev)
>  {
>  	struct device *dev = &pdev->dev;
>  	struct device_node *np = pdev->dev.of_node;
>  	struct device_node *np_lcpa;
>  	struct d40_base *base;
> -	struct resource *res;
>  	struct resource res_lcpa;
>  	void *dmaenginem_reg_group;
>  	int num_reserved_chans;
> @@ -3844,26 +3911,12 @@ static int __init d40_probe(struct platform_device *pdev)
>  		d40_err(dev, "Failed to ioremap LCPA region\n");
>  		goto report_failure;
>  	}
> -	/* If lcla has to be located in ESRAM we don't need to allocate */
> -	if (base->plat_data->use_esram_lcla) {

Does it break old dts's back compatiblity?

Frank

> -		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
> -							"lcla_esram");
> -		if (!res) {
> -			ret = -ENOENT;
> -			d40_err(dev,
> -				"No \"lcla_esram\" memory resource\n");
> -			goto report_failure;
> -		}
> -		base->lcla_pool.base = devm_ioremap(dev, res->start,
> -						    resource_size(res));
> -		if (!base->lcla_pool.base) {
> -			ret = -ENOMEM;
> -			d40_err(dev, "Failed to ioremap LCLA region\n");
> -			goto report_failure;
> -		}
> -		writel(res->start, base->virtbase + D40_DREG_LCLA);
> -
> -	} else {
> +	ret = d40_lcla_sram_setup(base);
> +	if (ret) {
> +		dev_err_probe(dev, ret, "Failed to set up LCLA SRAM\n");
> +		goto destroy_cache;
> +	}
> +	if (!base->lcla_pool.esram) {
>  		ret = d40_lcla_allocate(base);
>  		if (ret) {
>  			d40_err(dev, "Failed to allocate LCLA area\n");
> @@ -3879,26 +3932,6 @@ static int __init d40_probe(struct platform_device *pdev)
>  		goto destroy_cache;
>  	}
>
> -	if (base->plat_data->use_esram_lcla) {
> -
> -		base->lcpa_regulator = regulator_get(base->dev, "lcla_esram");
> -		if (IS_ERR(base->lcpa_regulator)) {
> -			d40_err(dev, "Failed to get lcpa_regulator\n");
> -			ret = PTR_ERR(base->lcpa_regulator);
> -			base->lcpa_regulator = NULL;
> -			goto destroy_cache;
> -		}
> -
> -		ret = regulator_enable(base->lcpa_regulator);
> -		if (ret) {
> -			d40_err(dev,
> -				"Failed to enable lcpa_regulator\n");
> -			regulator_put(base->lcpa_regulator);
> -			base->lcpa_regulator = NULL;
> -			goto destroy_cache;
> -		}
> -	}
> -
>  	writel_relaxed(D40_DREG_GCC_ENABLE_ALL, base->virtbase + D40_DREG_GCC);
>
>  	pm_runtime_irq_safe(base->dev);
> @@ -3954,22 +3987,18 @@ static int __init d40_probe(struct platform_device *pdev)
>  		dma_unmap_single(base->dev, base->lcla_pool.dma_addr,
>  				 SZ_1K * base->num_phy_chans,
>  				 DMA_TO_DEVICE);
> -
> -	if (!base->plat_data->use_esram_lcla &&
> -	    !base->lcla_pool.base_unaligned && base->lcla_pool.base)
> +	if (!base->lcla_pool.base_unaligned && base->lcla_pool.base)
>  		free_pages((unsigned long)base->lcla_pool.base,
>  			   base->lcla_pool.alloc_order);
>
>  	kfree(base->lcla_pool.base_unaligned);
> -
> -	if (base->lcpa_regulator) {
> -		regulator_disable(base->lcpa_regulator);
> -		regulator_put(base->lcpa_regulator);
> -	}
> +	if (base->lcla_link)
> +		device_link_del(base->lcla_link);
> +	if (base->lcla_dev)
> +		put_device(base->lcla_dev);
>
>   report_failure:
> -	d40_err(dev, "probe failed\n");
> -	return ret;
> +	return dev_err_probe(dev, ret, "probe failed\n");
>  }
>
>  static const struct of_device_id d40_match[] = {
> @@ -3978,15 +4007,17 @@ static const struct of_device_id d40_match[] = {
>  };
>
>  static struct platform_driver d40_driver = {
> +	.probe = d40_probe,
>  	.driver = {
>  		.name  = D40_NAME,
>  		.pm = &dma40_pm_ops,
>  		.of_match_table = d40_match,
> +		.suppress_bind_attrs = true,
>  	},
>  };
>
>  static int __init stedma40_init(void)
>  {
> -	return platform_driver_probe(&d40_driver, d40_probe);
> +	return platform_driver_register(&d40_driver);
>  }
>  subsys_initcall(stedma40_init);
>
> ---
> base-commit: becfc375b0ee95818c531ed43ecda26c90f7617a
> change-id: 20261115-ux500-dma40-powerdomain-135a566b03ff
>
> Best regards,
> --
> Linus Walleij <linusw@kernel.org>
>

  reply	other threads:[~2026-11-18 19:53 UTC|newest]

Thread overview: 3+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-15 21:26 Linus Walleij
2026-11-18 19:53 ` Frank Li [this message]
2026-11-18 20:19   ` Linus Walleij

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=av4CJkri6LQO9FxG@SMW015318 \
    --to=frank.li@oss.nxp.com \
    --cc=Frank.Li@kernel.org \
    --cc=dmaengine@vger.kernel.org \
    --cc=linusw@kernel.org \
    --cc=linux-arm-kernel@lists.infradead.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-pm@vger.kernel.org \
    --cc=ulfh@kernel.org \
    --cc=vkoul@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®