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 06/11] iio: adc: stm32-mdf: configure cic filters and sample rates
Date: Wed, 18 Nov 2026 16:17:51 +0100 [thread overview]
Message-ID: <20261118-upstream_mdf_v2-v2-6-7939d3c3720a@foss.st.com> (raw)
In-Reply-To: <20261118-upstream_mdf_v2-v2-0-7939d3c3720a@foss.st.com>
MDF output sample rates depend on the serial clock and the decimation
applied by the CIC and reshape filters. Add the calculations needed to
derive these settings from a requested sampling frequency.
Compute CIC gain and data scaling for the selected filter order and
decimation to maximize output signal dynamic.
Check serial and processing clock constraints, and configure the CCK
rate when needed.
Signed-off-by: Olivier Moysan <olivier.moysan@foss.st.com>
---
drivers/iio/adc/stm32-mdf-adc.c | 404 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 404 insertions(+)
diff --git a/drivers/iio/adc/stm32-mdf-adc.c b/drivers/iio/adc/stm32-mdf-adc.c
index 411af78911c9..eae7a4fa1485 100644
--- a/drivers/iio/adc/stm32-mdf-adc.c
+++ b/drivers/iio/adc/stm32-mdf-adc.c
@@ -182,6 +182,64 @@ static const unsigned int stm32_mdf_hpf_cutoff_ratio[] = {
* where N is filter order and D the CIC decimation factor.
* Following table gives the maximum decimation ratio for filter order [0..5].
*/
+static const unsigned int stm32_mdf_cic_max_decim_sitf[] = {
+512, 512, 512, 322, 76, 32
+};
+
+/* Gain (dB) x 10 according to scale value in hex */
+static const struct stm32_mdf_scales stm32_mdf_scale_table[] = {
+ {0x20, -482, -2558},
+ {0x21, -446, -1706},
+ {0x22, -421, -1280},
+ {0x23, -386, -853},
+ {0x24, -361, -640},
+ {0x25, -326, -427},
+ {0x26, -301, -320},
+ {0x27, -266, -213},
+ {0x28, -241, -160},
+ {0x29, -206, -107},
+ {0x2A, -181, -80},
+ {0x2B, -145, -53},
+ {0x2C, -120, -40},
+ {0x2D, -85, -27},
+ {0x2E, -60, -20},
+ {0x2F, -25, -13},
+ {0x00, 0, 10},
+ {0x01, 35, 15},
+ {0x02, 60, 20},
+ {0x03, 95, 30},
+ {0x04, 120, 40},
+ {0x05, 156, 60},
+ {0x06, 181, 80},
+ {0x07, 216, 120},
+ {0x08, 241, 160},
+ {0x09, 276, 240},
+ {0x0A, 301, 320},
+ {0x0B, 336, 480},
+ {0x0C, 361, 640},
+ {0x0D, 396, 960},
+ {0x0E, 421, 1280},
+ {0x0F, 457, 1920},
+ {0x10, 482, 2560},
+ {0x11, 517, 3840},
+ {0x12, 542, 5120},
+ {0x13, 577, 7680},
+ {0x14, 602, 10240},
+ {0x15, 637, 15360},
+ {0x16, 662, 20480},
+ {0x17, 697, 30720},
+ {0x18, 722, 40960},
+};
+
+/* Prime number 1000 x log10 table */
+static const struct stm32_mdf_log10 stm32_mdf_log_table[] = {
+ {2, 301}, {3, 477}, {5, 699}, {7, 845}, {11, 1041}, {13, 1114}, {17, 1230}, {19, 1279},
+ {23, 1362}, {29, 1462}, {31, 1491}, {37, 1568}, {41, 1613}, {43, 1633}, {47, 1672},
+ {53, 1724}, {59, 1771}, {61, 1785}, {67, 1826}, {71, 1851}, {73, 1863}, {79, 1898},
+ {83, 1919}, {89, 1949}, {97, 1987}, {101, 2004}, {103, 2013}, {107, 2029}, {109, 2037},
+ {113, 2053}, {127, 2104}
+};
+
static bool stm32_mdf_adc_readable_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
@@ -271,6 +329,352 @@ static struct stm32_mdf_adc *stm32_mdf_get_filter_by_handle(struct stm32_mdf *md
return NULL;
}
+static int stm32_mdf_adc_compute_scale(struct device *dev, unsigned int decim,
+ unsigned int order, unsigned int data_size)
+{
+ unsigned long max = ARRAY_SIZE(stm32_mdf_log_table);
+ unsigned int prime_factors[16];
+ unsigned int num, div, logd = 0;
+ int i, j, scale;
+
+ /* Decompose decimation ratio D, as prime number factors, to compute log10(D) */
+ j = 0;
+ num = decim;
+ while (num > 1) {
+ i = 0;
+ while (i < max) {
+ div = stm32_mdf_log_table[i].raw;
+ if (!(num % div)) {
+ prime_factors[j] = stm32_mdf_log_table[i].log;
+ num = num / div;
+ j++;
+ break;
+ }
+ i++;
+ }
+ if (i == max) {
+ dev_warn(dev, "Failed to set scale. Output signal may saturate.\n");
+ return 0;
+ }
+ }
+
+ for (i = 0; i < j; i++)
+ logd += prime_factors[i];
+
+ /* scale = 20 * ((DS - 1) * log10(2) - NF * log10(D)) */
+ scale = 20 * ((data_size - 1) * stm32_mdf_log_table[0].log - order * logd);
+
+ return scale;
+}
+
+static int stm32_mdf_adc_apply_filters_config(struct stm32_mdf_adc *adc, unsigned int scale)
+{
+ struct stm32_mdf_adc *adc_inter;
+ u32 msk, val;
+ int ret, cnt = 0;
+
+ /* Apply conf from filter0 to interleaved filters if any */
+ if (MDF_IS_FILTER0(adc) && adc->mdf->nb_interleave) {
+ list_for_each_entry(adc_inter, &adc->mdf->filter_list, entry) {
+ if (MDF_IS_INTERLEAVED_FILT_NOT_0(adc_inter)) {
+ adc_inter->datsrc = adc->datsrc;
+ adc_inter->cicmode = adc->cicmode;
+ adc_inter->decim_cic = adc->decim_cic;
+ adc_inter->nbdis = adc->nbdis;
+ adc_inter->hpf_cutoff = adc->hpf_cutoff;
+
+ stm32_mdf_adc_apply_filters_config(adc_inter, scale);
+ cnt++;
+ }
+ }
+ if (cnt != adc->mdf->nb_interleave - 1) {
+ dev_err(adc->dev, "Interleaved filter number [%d] / expected [%d]\n",
+ cnt, adc->mdf->nb_interleave - 1);
+ return -EINVAL;
+ }
+ }
+
+ /* Configure delay */
+ ret = regmap_update_bits(adc->regmap, MDF_DLYCR_REG, MDF_DLYCR_SKPDLY_MASK, adc->delay);
+ if (ret)
+ return ret;
+
+ /* Configure NBDIS */
+ if (adc->nbdis) {
+ ret = regmap_update_bits(adc->regmap, MDF_DFLTCR_REG, MDF_DFLTCR_NBDIS_MASK,
+ FIELD_PREP(MDF_DFLTCR_NBDIS_MASK, adc->nbdis));
+ if (ret)
+ return ret;
+ }
+
+ /* Configure CICR */
+ msk = MDF_SITFCR_SCKSRC_MASK | MDF_DFLTCICR_CICMOD_MASK |
+ MDF_DFLTCICR_MCICD_MASK | MDF_DFLTCICR_SCALE_MASK;
+ val = FIELD_PREP(MDF_SITFCR_SCKSRC_MASK, adc->datsrc) |
+ FIELD_PREP(MDF_DFLTCICR_CICMOD_MASK, adc->cicmode) |
+ FIELD_PREP(MDF_DFLTCICR_MCICD_MASK, adc->decim_cic - 1) |
+ FIELD_PREP(MDF_DFLTCICR_SCALE_MASK, scale);
+
+ ret = regmap_update_bits(adc->regmap, MDF_DFLTCICR_REG, msk, val);
+ if (ret)
+ return ret;
+
+ /* Configure RSFR & HPF */
+ if (adc->hpf_cutoff == STM32_MDF_HPF_BYPASS)
+ val = MDF_DFLTRSFR_HPFBYP;
+ else
+ val = FIELD_PREP(MDF_DFLTRSFR_HPFC_MASK, adc->hpf_cutoff);
+ val |= adc->rsflt_bypass ? MDF_DFLTRSFR_RSFLTBYP : 0;
+ msk = MDF_DFLTRSFR_RSFLTBYP | MDF_DFLTRSFR_HPFBYP | MDF_DFLTRSFR_HPFC_MASK;
+
+ return regmap_update_bits(adc->regmap, MDF_DFLTRSFR_REG, msk, val);
+}
+
+static int stm32_mdf_adc_set_filters_config(struct iio_dev *indio_dev, unsigned int decim)
+{
+ struct stm32_mdf_adc *adc = iio_priv(indio_dev);
+ struct device *dev = &indio_dev->dev;
+ unsigned int decim_cic, decim_rsflt = 1;
+ unsigned int data_size = STM32_MDF_DATA_RES, order = adc->cicmode;
+ u64 max;
+ int i, d, log, scale, max_scale, gain_lin;
+
+ if (!adc->rsflt_bypass) {
+ decim_rsflt = 4;
+ data_size -= 2;
+
+ /* Check if total decimation factor is a multiple of reshape filter decimation */
+ if (decim % decim_rsflt) {
+ dev_err(dev, "Total decimation factor [%d] not multiple of [%d]\n",
+ decim, decim_rsflt);
+ return -EINVAL;
+ }
+ }
+
+ decim_cic = DIV_ROUND_CLOSEST(decim, decim_rsflt);
+ if (decim_cic < MDF_DFLTCICR_MCICD_MIN ||
+ decim_cic > stm32_mdf_cic_max_decim_sitf[order]) {
+ dev_err(dev, "Decimation factor [%d] out of range for CIC filter order [%d]\n",
+ decim_cic, adc->cicmode);
+ return -EINVAL;
+ }
+
+ /*
+ * Compute scaling:
+ * max scale = 20 * log10( 2 exp DS / D exp NF )
+ * - DS = max data size at scale output (RSFLT on: DS = 22 / RSFLT off: DS = 24)
+ * - NF = Main CIC filter order
+ */
+ if (is_power_of_2(decim_cic)) {
+ /*
+ * Decimation ratio is a power of 2: D = 2 exp n
+ * max scale = 20 * (DS - n * NF) * log10(2)
+ */
+ log = stm32_mdf_log_table[0].log;
+
+ /* Compute max scale (dB) * 1000 */
+ max_scale = (20 * (data_size - 1 - (order * (fls(decim_cic) - 1))) * log);
+ } else {
+ /*
+ * Decimation ratio is not a power of 2
+ * max scale = 20 * ((DS - 1) * log10(2) - NF * log10(D))
+ */
+ max_scale = stm32_mdf_adc_compute_scale(dev, decim_cic, order, data_size);
+ }
+
+ dev_dbg(dev, "Filter order [%d], decimation [%d], data size [%d], max scale [%d]\n",
+ order, decim_cic, data_size, max_scale / 1000);
+
+ /*
+ * Find scale register setting.
+ * Limit max_scale accuracy to first decimal for comparison with scale table values.
+ */
+ max_scale = DIV_ROUND_CLOSEST(max_scale, 100);
+ i = ARRAY_SIZE(stm32_mdf_scale_table) - 1;
+ while (i > 0) {
+ if (stm32_mdf_scale_table[i].gain_db < max_scale)
+ break;
+ i--;
+ };
+ scale = stm32_mdf_scale_table[i].scale;
+ gain_lin = stm32_mdf_scale_table[i].gain_lin;
+
+ dev_dbg(dev, "Set scale to [%d]dB: [0x%x]\n", stm32_mdf_scale_table[i].gain_db / 10, scale);
+
+ adc->decim_cic = decim_cic;
+
+ /*
+ * Calculate maximum DFLT output filter
+ * max = K * G
+ * - Fastsinc (order 0): G = 2 * d^2 * gain_lin
+ * - Sinc order 1 to 5: G = d^N * gain_lin
+ * - RSFLT off: K = 1, d = decim
+ * - RSFLT on: K = 2.98, d = decim_cic
+ * N = CIC filter order, decim = total decimation ratio, decim_cic = CIC decimation ratio
+ * gain_lin is multiplied by a 10 factor in stm32_mdf_scale_table, and K with a 100 factor.
+ */
+ if (adc->rsflt_bypass) {
+ d = decim;
+ max = 100;
+ } else {
+ d = decim_cic;
+ max = 298;
+ }
+
+ if (order) {
+ i = 0;
+ while (i < order) {
+ max *= d;
+ i++;
+ }
+ } else {
+ max *= 2 * d * d;
+ }
+
+ if (gain_lin > 0) {
+ max *= gain_lin;
+ max = DIV_ROUND_CLOSEST_ULL(max, 1000);
+ }
+ if (gain_lin < 0) {
+ max = DIV_ROUND_CLOSEST_ULL(max, -gain_lin);
+ max = DIV_ROUND_CLOSEST_ULL(max, 10);
+ }
+
+ adc->dflt_max = max;
+
+ dev_dbg(dev, "DFLT maximum output [%d]\n", adc->dflt_max);
+
+ return stm32_mdf_adc_apply_filters_config(adc, scale);
+}
+
+static int stm32_mdf_adc_check_clock_config(struct stm32_mdf_adc *adc, unsigned long *sck_freq)
+{
+ unsigned long cck_expected_freq;
+ unsigned int ratio, cic_ratio;
+ int ret, error = 0;
+
+ /*
+ * The CCK rate is requested by its consumer through the clock framework.
+ * The serial interface clock sck (aka cck) is derived from MDF kernel clock frequency.
+ * The kernel clock rate may have been changed by another consumer, or MDF dividers
+ * may have been updated through clk_get_rate() call.
+ * Ensure that kernel clock rate and MDF dividers, still provide the right sck/cck rate
+ */
+ cck_expected_freq = stm32_mdf_core_get_cck(adc->mdf);
+ if (*sck_freq != cck_expected_freq) {
+ dev_dbg(adc->dev, "Wrong sck_freq [%lu]Hz. Expected [%lu]Hz.\n",
+ *sck_freq, cck_expected_freq);
+ error |= STM32_MDF_ERR_SCK_FREQ;
+ }
+
+ /*
+ * Mode SPI: check Fproc >= 4 * Fsck
+ * Mode LF SPI: check Fproc >= 2 * Fsck
+ */
+ ratio = DIV_ROUND_CLOSEST(adc->mdf->fproc, *sck_freq);
+ if ((adc->sitf->mode == STM32_MDF_MODE_SPI && ratio <= 4) ||
+ (adc->sitf->mode == STM32_MDF_MODE_LF_SPI && ratio <= 2)) {
+ dev_dbg(adc->dev, "Wrong Fproc/Fsck ratio [%d]. sitf mode [%d], RSFLT [%s]\n",
+ ratio, adc->sitf->mode, adc->rsflt_bypass ? "off" : "on");
+ error |= STM32_MDF_ERR_MODE_RATIO;
+ }
+
+ /* RSFLT enabled: check Fproc > 24 * Fsck / (MCICD+1) */
+ cic_ratio = DIV_ROUND_CLOSEST(24, adc->decim_cic);
+ if (!adc->rsflt_bypass && ratio <= cic_ratio)
+ error |= STM32_MDF_ERR_DECIM_RATIO;
+
+ /* If we found an error, try to restore clocks initial settings */
+ if (error) {
+ ret = stm32_mdf_core_restore_cck(adc->mdf);
+ if (ret < 0)
+ goto err;
+
+ *sck_freq = clk_get_rate(adc->sitf->sck);
+ if (!*sck_freq) {
+ ret = -EINVAL;
+ goto err;
+ }
+ }
+
+ return 0;
+
+err:
+ dev_err(adc->dev, "Wrong clock configuration [0x%x]. Clock recovering returned [%d]\n",
+ error, ret);
+
+ return ret;
+}
+
+static int __maybe_unused mdf_adc_set_samp_freq(struct iio_dev *indio_dev)
+{
+ struct stm32_mdf_adc *adc = iio_priv(indio_dev);
+ struct device *dev = &indio_dev->dev;
+ unsigned int decim_ratio;
+ unsigned long delta, delta_ppm, sck_freq, sample_freq = adc->requested_sample_freq;
+ u64 nbdis;
+ int ret;
+
+ sck_freq = clk_get_rate(adc->sitf->sck);
+ if (!sck_freq) {
+ dev_err(dev, "Unexpected serial clock frequency: 0Hz\n");
+ ret = -EINVAL;
+ goto err;
+ }
+
+ /*
+ * In analog use cases, the sampling frequency may not be already set in IIO sysfs.
+ * (In audio use cases, the sampling frequency is always provided on stream startup)
+ * If requested sampling frequency is 0, set a default frequency.
+ * The default frequency is computed from the default decimation ratio.
+ * This ensures that a filter configuration can be found whatever the selected filter
+ * order. (Most constrained case is order 5)
+ */
+ if (!sample_freq)
+ sample_freq = sck_freq / MDF_DEFAULT_DECIM_RATIO;
+
+ ret = stm32_mdf_adc_check_clock_config(adc, &sck_freq);
+ if (ret)
+ goto err;
+
+ decim_ratio = DIV_ROUND_CLOSEST(sck_freq, sample_freq);
+
+ delta = abs(sck_freq - (decim_ratio * sample_freq));
+ delta_ppm = (1000000 * delta) / sck_freq;
+ if (delta_ppm > 1000)
+ dev_warn(dev, "Sample rate deviation [%lu] ppm: [%lu] vs [%lu] Hz\n",
+ delta_ppm, sck_freq / decim_ratio, sample_freq);
+ else if (delta)
+ dev_dbg(dev, "Sample rate deviation [%lu] ppm: [%lu] vs [%lu] Hz\n",
+ delta_ppm, sck_freq / decim_ratio, sample_freq);
+
+ /*
+ * Convert settling time into a minimum number of output sample to discard before releasing
+ * the data. This allows to drop the samples affected by the impulse response of the
+ * filter and wait for stable data.
+ */
+ nbdis = DIV_ROUND_UP_ULL((u64)adc->stu * sample_freq, 1000000);
+ if (nbdis > MDF_DFLTCR_NBDIS_MAX) {
+ dev_warn(dev, "NBDIS [%llu] too large. Force to [%lu]\n",
+ nbdis, MDF_DFLTCR_NBDIS_MAX);
+ adc->nbdis = MDF_DFLTCR_NBDIS_MAX;
+ } else {
+ adc->nbdis = nbdis;
+ dev_dbg(dev, "Settling time [%u] us. NBDIS set to [%u] samples\n",
+ adc->stu, adc->nbdis);
+ }
+
+ ret = stm32_mdf_adc_set_filters_config(indio_dev, decim_ratio);
+ if (ret < 0)
+ goto err;
+
+ adc->sample_freq = DIV_ROUND_CLOSEST(sck_freq, decim_ratio);
+ adc->decim_ratio = decim_ratio;
+
+err:
+ return ret;
+}
+
static int stm32_mdf_get_sitf(struct device *dev, struct stm32_mdf_adc *adc,
struct fwnode_handle *sitf_node)
{
--
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 ` [PATCH v2 03/11] iio: adc: stm32-mdf: add cck clocks provider Olivier Moysan
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 ` Olivier Moysan [this message]
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-6-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®