From: Olivier Moysan <olivier.moysan@foss.st.com>
To: "Jonathan Cameron" <jic23@kernel.org>,
"David Lechner" <dlechner@baylibre.com>,
"Nuno Sá" <nuno.sa@analog.com>,
"Andy Shevchenko" <andy@kernel.org>,
"Rob Herring" <robh@kernel.org>,
"Krzysztof Kozlowski" <krzk+dt@kernel.org>,
"Conor Dooley" <conor+dt@kernel.org>,
"Maxime Coquelin" <mcoquelin.stm32@gmail.com>,
"Alexandre Torgue" <alexandre.torgue@foss.st.com>,
"Philipp Zabel" <p.zabel@pengutronix.de>,
"Sumit Semwal" <sumit.semwal@linaro.org>,
"Christian König" <christian.koenig@amd.com>,
"Philipp Stanner" <phasta@kernel.org>,
"Arnaud Pouliquen" <arnaud.pouliquen@foss.st.com>,
"Liam Girdwood" <lgirdwood@gmail.com>,
"Mark Brown" <broonie@kernel.org>,
"Jaroslav Kysela" <perex@perex.cz>,
"Takashi Iwai" <tiwai@suse.com>,
"Fabrice Gasnier" <fabrice.gasnier@foss.st.com>
Cc: <linux-iio@vger.kernel.org>, <devicetree@vger.kernel.org>,
<linux-stm32@st-md-mailman.stormreply.com>,
<linux-arm-kernel@lists.infradead.org>,
<linux-kernel@vger.kernel.org>, <linux-media@vger.kernel.org>,
<dri-devel@lists.freedesktop.org>,
<linaro-mm-sig@lists.linaro.org>, <linux-sound@vger.kernel.org>,
"Olivier Moysan" <olivier.moysan@foss.st.com>
Subject: [PATCH v2 03/11] iio: adc: stm32-mdf: add cck clocks provider
Date: Wed, 18 Nov 2026 16:17:48 +0100 [thread overview]
Message-ID: <20261118-upstream_mdf_v2-v2-3-7939d3c3720a@foss.st.com> (raw)
In-Reply-To: <20261118-upstream_mdf_v2-v2-0-7939d3c3720a@foss.st.com>
MDF clock outputs can supply the serial interfaces and their external
converters. Register CCK0 and CCK1 with the common clock framework so that
consumers can configure and gate these outputs through the clock API.
Implement rate selection using the processing and CCK dividers, checking
the hardware limits and clock accuracy.
Expose helpers for child drivers to retrieve the CCK rate and restore its
configuration.
Signed-off-by: Olivier Moysan <olivier.moysan@foss.st.com>
---
drivers/iio/adc/stm32-mdf-core.c | 398 ++++++++++++++++++++++++++++++++++++++-
drivers/iio/adc/stm32-mdf.h | 5 +
2 files changed, 402 insertions(+), 1 deletion(-)
diff --git a/drivers/iio/adc/stm32-mdf-core.c b/drivers/iio/adc/stm32-mdf-core.c
index ca50ce566a43..4e462c6c42bc 100644
--- a/drivers/iio/adc/stm32-mdf-core.c
+++ b/drivers/iio/adc/stm32-mdf-core.c
@@ -8,6 +8,7 @@
#include <linux/cleanup.h>
#include <linux/clk.h>
+#include <linux/clk-provider.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/module.h>
@@ -82,6 +83,7 @@ static const struct regmap_config stm32_mdf_regmap_cfg = {
* @n_active_ch: number of active channels
* @lock: lock to manage common resources
* @kclk_rate: save kclk rate at probe
+ * @cck_freq_actual: actual output cck clocks frequency
* @exclusive_flg: exclusive rate request flag
*/
struct stm32_mdf_priv {
@@ -94,10 +96,24 @@ struct stm32_mdf_priv {
atomic_t n_active_ch;
spinlock_t lock; /* Manage common resources race conditions */
unsigned long kclk_rate;
+ unsigned long cck_freq_actual;
bool exclusive_flg;
};
+#define STM32_MDF_MAX_CCK 2
#define STM32_MDF_MP23_FILTER_NB 4
+#define STM32_MDF_MAX_CCK_RATE 25000000
+
+struct clk_mdf_cck {
+ struct clk_hw hw;
+ struct stm32_mdf_priv *priv;
+};
+
+static const struct clk_parent_data clk_cck_parent_data[] = {
+ { .index = 0 },
+};
+
+#define to_clk_mdf_cck(_hw) container_of(_hw, struct clk_mdf_cck, hw)
static inline struct stm32_mdf_priv *to_stm32_mdf_priv(struct stm32_mdf *mdf)
{
@@ -194,6 +210,96 @@ int stm32_mdf_core_trigger(struct stm32_mdf *mdf)
}
EXPORT_SYMBOL_GPL(stm32_mdf_core_trigger);
+/**
+ * stm32_mdf_core_get_cck() - Get the configured CCK frequency
+ * @mdf: MDF instance
+ *
+ * Return: The actual CCK frequency, in Hz.
+ */
+unsigned long stm32_mdf_core_get_cck(struct stm32_mdf *mdf)
+{
+ struct stm32_mdf_priv *priv = to_stm32_mdf_priv(mdf);
+
+ return priv->cck_freq_actual;
+}
+EXPORT_SYMBOL_GPL(stm32_mdf_core_get_cck);
+
+/**
+ * stm32_mdf_core_lock_kclk_rate() - Prevent changes to the MDF kernel clock rate
+ * @mdf: MDF instance
+ *
+ * Request an exclusive rate on the kernel clock when no MDF channels are
+ * active. While channels are active, the rate is already held exclusive by
+ * the start operation.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+int stm32_mdf_core_lock_kclk_rate(struct stm32_mdf *mdf)
+{
+ struct stm32_mdf_priv *priv = to_stm32_mdf_priv(mdf);
+ struct device *dev = &priv->pdev->dev;
+ int ret;
+
+ if (!atomic_read(&priv->n_active_ch)) {
+ /* Request rate exclusivity on kernel clock right now */
+ ret = clk_rate_exclusive_get(priv->kclk);
+ if (ret < 0) {
+ dev_err(dev, "Failed to get exclusive rate on kernel clock: [%d]\n", ret);
+ return ret;
+ }
+
+ priv->exclusive_flg = true;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(stm32_mdf_core_lock_kclk_rate);
+
+/**
+ * stm32_mdf_core_unlock_kclk_rate() - Release the MDF kernel clock rate lock
+ * @mdf: MDF instance
+ *
+ * Release an exclusive rate acquired by stm32_mdf_core_lock_kclk_rate() when
+ * no MDF channels are active. The lock is retained while channels are active.
+ */
+void stm32_mdf_core_unlock_kclk_rate(struct stm32_mdf *mdf)
+{
+ struct stm32_mdf_priv *priv = to_stm32_mdf_priv(mdf);
+
+ if (!atomic_read(&priv->n_active_ch)) {
+ clk_rate_exclusive_put(priv->kclk);
+ priv->exclusive_flg = false;
+ }
+}
+EXPORT_SYMBOL_GPL(stm32_mdf_core_unlock_kclk_rate);
+
+/**
+ * stm32_mdf_core_restore_cck() - Restore the MDF kernel clock rate
+ * @mdf: MDF instance
+ *
+ * Set the kernel clock to the rate recorded when the MDF core was probed.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+int stm32_mdf_core_restore_cck(struct stm32_mdf *mdf)
+{
+ struct stm32_mdf_priv *priv = to_stm32_mdf_priv(mdf);
+ struct device *dev = &priv->pdev->dev;
+ int ret;
+
+ ret = clk_set_rate(priv->kclk, priv->kclk_rate);
+ if (ret) {
+ dev_err(dev, "Failed to change kernel clock rate from [%lu]Hz to [%lu]Hz: [%d]\n",
+ clk_get_rate(priv->kclk), priv->kclk_rate, ret);
+ return ret;
+ }
+
+ dev_dbg(dev, "MDF kernel clock rate changed to [%lu]Hz.\n", priv->kclk_rate);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(stm32_mdf_core_restore_cck);
+
/**
* stm32_mdf_core_stop_mdf() - Stop an MDF channel
* @mdf: MDF instance
@@ -223,11 +329,301 @@ int stm32_mdf_core_stop_mdf(struct stm32_mdf *mdf)
}
EXPORT_SYMBOL_GPL(stm32_mdf_core_stop_mdf);
+static int stm32_mdf_core_cck_divider_set_rate(struct platform_device *pdev,
+ struct stm32_mdf_priv *priv,
+ unsigned long rate,
+ unsigned long parent_rate)
+{
+ struct device *dev = &pdev->dev;
+ unsigned long ratio, delta, delta_ppm, procdiv;
+ unsigned int cckdiv;
+ int ret;
+
+ if (!rate || rate > STM32_MDF_MAX_CCK_RATE || !parent_rate)
+ return -EINVAL;
+
+ ratio = DIV_ROUND_CLOSEST(parent_rate, rate);
+ if (!ratio) {
+ dev_err(dev, "CCK frequency above kernel frequency\n");
+ return -EINVAL;
+ }
+
+ delta = abs(parent_rate - (ratio * rate));
+
+ delta_ppm = (1000000 * delta) / parent_rate;
+ if (delta_ppm > 1000) {
+ /* If frequency deviation is higher than 1000 ppm return error */
+ dev_dbg(dev, "CCK clock deviation [%lu] ppm too large: [%lu] vs [%lu] Hz\n",
+ delta_ppm, DIV_ROUND_CLOSEST(parent_rate, ratio), rate);
+ return -EINVAL;
+ } else if (delta_ppm) {
+ dev_dbg(dev, "CCK clock frequency not accurate: [%lu] ppm deviation\n", delta_ppm);
+ }
+
+ /*
+ * The total divider ratio must be split between proc divider and
+ * cck divider. Try to maximize cck divider first, to help fulfilling
+ * frequency ratio requirements between fproc and fcck.
+ */
+ cckdiv = min_t(unsigned long, ratio, MDF_CKG_CCKDIV_MAX);
+ while (ratio % cckdiv)
+ cckdiv--;
+ procdiv = ratio / cckdiv;
+
+ if (procdiv > MDF_PROCDIV_MAX) {
+ dev_err(dev, "Proc divider out of range: %lu > %lu\n", procdiv,
+ MDF_PROCDIV_MAX);
+ return -EINVAL;
+ }
+
+ priv->mdf.fproc = DIV_ROUND_CLOSEST(parent_rate, procdiv);
+
+ /* Configure CKGCR register */
+ dev_dbg(dev, "Set MDF dividers: CCKDIV [%u], PROCDIV [%lu]\n", cckdiv, procdiv);
+ ret = regmap_update_bits(priv->regmap, MDF_CKGCR_REG,
+ MDF_CKG_CCKDIV_MASK | MDF_CKG_PROCDIV_MASK,
+ FIELD_PREP(MDF_CKG_CCKDIV_MASK, cckdiv - 1) |
+ FIELD_PREP(MDF_CKG_PROCDIV_MASK, procdiv - 1));
+ if (!ret)
+ priv->cck_freq_actual = DIV_ROUND_CLOSEST(parent_rate, ratio);
+
+ return ret;
+}
+
+static int stm32_mdf_core_cck_set_rate(struct clk_hw *hw, unsigned long rate,
+ unsigned long parent_rate)
+{
+ struct clk_mdf_cck *clk = to_clk_mdf_cck(hw);
+ struct stm32_mdf_priv *priv = clk->priv;
+
+ return stm32_mdf_core_cck_divider_set_rate(priv->pdev, priv, rate, parent_rate);
+}
+
+static int stm32_mdf_core_cck_determine_rate(struct clk_hw *hw,
+ struct clk_rate_request *req)
+{
+ struct clk_mdf_cck *clk = to_clk_mdf_cck(hw);
+ struct stm32_mdf_priv *priv = clk->priv;
+ struct platform_device *pdev = priv->pdev;
+ unsigned long ratio;
+
+ if (!req->rate || req->rate > STM32_MDF_MAX_CCK_RATE || !req->best_parent_rate)
+ return -EINVAL;
+
+ ratio = DIV_ROUND_CLOSEST(req->best_parent_rate, req->rate);
+ if (!ratio) {
+ dev_err(&pdev->dev, "CCK frequency above kernel frequency\n");
+ return -EINVAL;
+ }
+
+ req->rate = DIV_ROUND_CLOSEST(req->best_parent_rate, ratio);
+
+ return 0;
+}
+
+static unsigned long stm32_mdf_core_cck_divider_recalc_rate(struct clk_hw *hw,
+ unsigned long parent_rate)
+{
+ struct clk_mdf_cck *clk = to_clk_mdf_cck(hw);
+ struct stm32_mdf_priv *priv = clk->priv;
+ unsigned int val;
+ unsigned int ratio;
+ int ret;
+
+ ret = regmap_read(priv->regmap, MDF_CKGCR_REG, &val);
+ if (ret)
+ /* Gives a hint that something is wrong */
+ return 0;
+
+ ratio = (FIELD_GET(MDF_CKG_PROCDIV_MASK, val) + 1) *
+ (FIELD_GET(MDF_CKG_CCKDIV_MASK, val) + 1);
+
+ return DIV_ROUND_CLOSEST_ULL((u64)parent_rate, ratio);
+};
+
+static const struct clk_ops clk_cck_ops = {
+ .recalc_rate = stm32_mdf_core_cck_divider_recalc_rate,
+ .set_rate = stm32_mdf_core_cck_set_rate,
+ .determine_rate = stm32_mdf_core_cck_determine_rate,
+};
+
+static struct clk_mdf_cck clk_cck;
+
+struct clk_cckx_gate {
+ struct clk_hw hw;
+ struct regmap *map;
+ u32 map_offset;
+ u8 bit_idx;
+ u8 flags;
+ spinlock_t *lock; /* Protect cckx gating */
+};
+
+#define to_clk_cckx_gate(_hw) container_of(_hw, struct clk_cckx_gate, hw)
+
+static inline u32 clk_cckx_gate_readl(struct clk_cckx_gate *gate)
+{
+ u32 val;
+
+ regmap_read(gate->map, gate->map_offset, &val);
+
+ return val;
+}
+
+static inline void clk_cckx_gate_writel(struct clk_cckx_gate *gate, u32 val)
+{
+ regmap_write(gate->map, gate->map_offset, val);
+}
+
+static void clk_cckx_gate_endisable(struct clk_hw *hw, int enable)
+{
+ struct clk_cckx_gate *gate = to_clk_cckx_gate(hw);
+ unsigned long flags = 0;
+ u32 reg;
+
+ if (gate->lock)
+ spin_lock_irqsave(gate->lock, flags);
+ else
+ __acquire(gate->lock);
+
+ reg = clk_cckx_gate_readl(gate);
+
+ if (enable)
+ reg |= BIT(gate->bit_idx);
+ else
+ reg &= ~BIT(gate->bit_idx);
+
+ clk_cckx_gate_writel(gate, reg);
+
+ if (gate->lock)
+ spin_unlock_irqrestore(gate->lock, flags);
+ else
+ __release(gate->lock);
+}
+
+static int clk_cckx_gate_enable(struct clk_hw *hw)
+{
+ clk_cckx_gate_endisable(hw, 1);
+
+ return 0;
+}
+
+static void clk_cckx_gate_disable(struct clk_hw *hw)
+{
+ clk_cckx_gate_endisable(hw, 0);
+}
+
+static int clk_cckx_gate_is_enabled(struct clk_hw *hw)
+{
+ struct clk_cckx_gate *gate = to_clk_cckx_gate(hw);
+ u32 reg;
+
+ reg = clk_cckx_gate_readl(gate);
+
+ reg &= BIT(gate->bit_idx);
+
+ return reg ? 1 : 0;
+}
+
+static const struct clk_ops clk_cckx_gate_ops = {
+ .enable = clk_cckx_gate_enable,
+ .disable = clk_cckx_gate_disable,
+ .is_enabled = clk_cckx_gate_is_enabled,
+};
+
+static struct clk_cckx_gate clk_cck0 = {
+ .map_offset = MDF_CKGCR_REG,
+ .bit_idx = 1,
+};
+
+static struct clk_cckx_gate clk_cck1 = {
+ .map_offset = MDF_CKGCR_REG,
+ .bit_idx = 2,
+};
+
+static int stm32_mdf_core_register_clock_provider(struct platform_device *pdev,
+ struct stm32_mdf_priv *priv)
+{
+ struct device_node *node = pdev->dev.of_node;
+ struct device *dev = &pdev->dev;
+ struct clk_hw_onecell_data *clk_data;
+ struct property *prop;
+ const char *clk_name;
+ u32 ckgcr = 0;
+ int index = 0, ret, clk_id;
+ struct clk_hw *mdf_hw[] = { &clk_cck0.hw, &clk_cck1.hw };
+ struct clk_cckx_gate *gate;
+
+ clk_cck.hw.init = CLK_HW_INIT_PARENTS_DATA("clk_cck", clk_cck_parent_data,
+ &clk_cck_ops, 0);
+ clk_cck0.hw.init = CLK_HW_INIT_HW(STM32_MDF_CCK0, &clk_cck.hw, &clk_cckx_gate_ops,
+ CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED);
+ clk_cck1.hw.init = CLK_HW_INIT_HW(STM32_MDF_CCK1, &clk_cck.hw, &clk_cckx_gate_ops,
+ CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED);
+
+ clk_cck.priv = priv;
+
+ ret = devm_clk_hw_register(dev, &clk_cck.hw);
+ if (ret)
+ return dev_err_probe(dev, ret, "Failed to register clk_cck");
+
+ clk_data = devm_kzalloc(dev, struct_size(clk_data, hws, STM32_MDF_MAX_CCK), GFP_KERNEL);
+ if (!clk_data)
+ return -ENOMEM;
+
+ of_property_for_each_string(node, "clock-output-names", prop, clk_name) {
+ if (index >= STM32_MDF_MAX_CCK) {
+ dev_err(dev, "Too many cck providers defined\n");
+ return -EINVAL;
+ }
+
+ if (!strncmp(clk_name, "cck0", 4)) {
+ clk_id = 0;
+ } else if (!strncmp(clk_name, "cck1", 4)) {
+ clk_id = 1;
+ } else {
+ dev_err(dev, "Unexpected cck clock provider name [%s]\n", clk_name);
+ return -EINVAL;
+ }
+
+ gate = to_clk_cckx_gate(mdf_hw[clk_id]);
+ gate->map = priv->regmap;
+
+ ret = devm_clk_hw_register(dev, mdf_hw[clk_id]);
+ if (ret)
+ return dev_err_probe(dev, ret, "Failed to register %s clock provider",
+ clk_name);
+
+ clk_data->hws[index] = mdf_hw[clk_id];
+
+ /* Configure the CCKx clock as output */
+ ckgcr |= clk_id ? MDF_CKG_CCK1DIR : MDF_CKG_CCK0DIR;
+
+ index++;
+ }
+
+ /*
+ * Set num to max number of clock. This allows any clocks indice below maximum
+ * in of_clk_hw_onecell_get, whatever the actual number of providers.
+ */
+ clk_data->num = STM32_MDF_MAX_CCK;
+ ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, clk_data);
+ if (ret) {
+ dev_err(dev, "Failed to add %s clock provider: %d\n",
+ clk_name ? clk_name : "", ret);
+ return ret;
+ }
+
+ /* Configure CKGCR register */
+ return regmap_update_bits(priv->regmap, MDF_CKGCR_REG,
+ MDF_CKG_CCK1DIR | MDF_CKG_CCK0DIR, ckgcr);
+}
+
static int stm32_mdf_core_parse_clocks(struct platform_device *pdev, struct stm32_mdf_priv *priv)
{
priv->kclk_rate = clk_get_rate(priv->kclk);
- return 0;
+ /* The consumer assigns the CCK rate after the provider is registered. */
+ return stm32_mdf_core_register_clock_provider(pdev, priv);
}
static int stm32_mdf_core_parse_of(struct platform_device *pdev, struct stm32_mdf_priv *priv)
diff --git a/drivers/iio/adc/stm32-mdf.h b/drivers/iio/adc/stm32-mdf.h
index b334769f8b17..e3617b181e28 100644
--- a/drivers/iio/adc/stm32-mdf.h
+++ b/drivers/iio/adc/stm32-mdf.h
@@ -174,6 +174,9 @@
#define STM32MP25_MDF_IPIDR_NUMBER 0x00110032
+#define STM32_MDF_CCK0 "clk_cck0"
+#define STM32_MDF_CCK1 "clk_cck1"
+
/*
* struct stm32_mdf - STM32 MDF driver common data (for all instances)
* @filter_list: pointer to filter interfaces list
@@ -216,6 +219,8 @@ static inline struct regmap *stm32_mdf_regmap_init(struct device *dev, struct cl
int stm32_mdf_core_start_mdf(struct stm32_mdf *mdf);
int stm32_mdf_core_stop_mdf(struct stm32_mdf *mdf);
int stm32_mdf_core_trigger(struct stm32_mdf *mdf);
+int stm32_mdf_core_restore_cck(struct stm32_mdf *mdf);
int stm32_mdf_core_lock_kclk_rate(struct stm32_mdf *mdf);
void stm32_mdf_core_unlock_kclk_rate(struct stm32_mdf *mdf);
+unsigned long stm32_mdf_core_get_cck(struct stm32_mdf *mdf);
--
2.43.0
next prev parent reply other threads:[~2026-11-18 15:18 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 15:17 [PATCH v2 00/11] iio: adc: stm32: add mdf support for stm32mp2 Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 01/11] dt-bindings: iio: adc: add stm32mp2 mdf filter Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 02/11] iio: adc: stm32-mdf: add core registration Olivier Moysan
2026-11-18 15:17 ` Olivier Moysan [this message]
2026-11-18 15:17 ` [PATCH v2 04/11] iio: adc: stm32-mdf: add serial interfaces support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 05/11] iio: adc: stm32-mdf: add digital filter device support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 06/11] iio: adc: stm32-mdf: configure cic filters and sample rates Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 07/11] iio: adc: stm32-mdf: add direct iio conversion support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 08/11] iio: adc: stm32-mdf: add dma buffered acquisition support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 09/11] iio: adc: stm32-mdf: add external timer trigger support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 10/11] iio: adc: stm32-mdf: add dmic audio filter support Olivier Moysan
2026-11-18 15:17 ` [PATCH v2 11/11] ASoC: stm32: add mdf dai support Olivier Moysan
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=20261118-upstream_mdf_v2-v2-3-7939d3c3720a@foss.st.com \
--to=olivier.moysan@foss.st.com \
--cc=alexandre.torgue@foss.st.com \
--cc=andy@kernel.org \
--cc=arnaud.pouliquen@foss.st.com \
--cc=broonie@kernel.org \
--cc=christian.koenig@amd.com \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=dlechner@baylibre.com \
--cc=dri-devel@lists.freedesktop.org \
--cc=fabrice.gasnier@foss.st.com \
--cc=jic23@kernel.org \
--cc=krzk+dt@kernel.org \
--cc=lgirdwood@gmail.com \
--cc=linaro-mm-sig@lists.linaro.org \
--cc=linux-arm-kernel@lists.infradead.org \
--cc=linux-iio@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-media@vger.kernel.org \
--cc=linux-sound@vger.kernel.org \
--cc=linux-stm32@st-md-mailman.stormreply.com \
--cc=mcoquelin.stm32@gmail.com \
--cc=nuno.sa@analog.com \
--cc=p.zabel@pengutronix.de \
--cc=perex@perex.cz \
--cc=phasta@kernel.org \
--cc=robh@kernel.org \
--cc=sumit.semwal@linaro.org \
--cc=tiwai@suse.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®