Merge remote-tracking branches 'asoc/topic/sgtl5000', 'asoc/topic/si476x', 'asoc...
authorMark Brown <broonie@kernel.org>
Thu, 18 Jan 2018 11:56:14 +0000 (11:56 +0000)
committerMark Brown <broonie@kernel.org>
Thu, 18 Jan 2018 11:56:14 +0000 (11:56 +0000)
Documentation/devicetree/bindings/sound/simple-card.txt
Documentation/devicetree/bindings/sound/st,stm32-adfsdm.txt [new file with mode: 0644]
sound/soc/codecs/sgtl5000.c
sound/soc/codecs/si476x.c
sound/soc/codecs/spdif_receiver.c
sound/soc/codecs/spdif_transmitter.c
sound/soc/stm/Kconfig
sound/soc/stm/Makefile
sound/soc/stm/stm32_adfsdm.c [new file with mode: 0644]

index 166f2290233b2f55f11dabe42ea9362e0697e30d..17c13e74667da8d2135fa3360926909b6dbc569b 100644 (file)
@@ -140,6 +140,7 @@ sound {
        simple-audio-card,name = "Cubox Audio";
 
        simple-audio-card,dai-link@0 {          /* I2S - HDMI */
+               reg = <0>;
                format = "i2s";
                cpu {
                        sound-dai = <&audio1 0>;
@@ -150,6 +151,7 @@ sound {
        };
 
        simple-audio-card,dai-link@1 {          /* S/PDIF - HDMI */
+               reg = <1>;
                cpu {
                        sound-dai = <&audio1 1>;
                };
@@ -159,6 +161,7 @@ sound {
        };
 
        simple-audio-card,dai-link@2 {          /* S/PDIF - S/PDIF */
+               reg = <2>;
                cpu {
                        sound-dai = <&audio1 1>;
                };
diff --git a/Documentation/devicetree/bindings/sound/st,stm32-adfsdm.txt b/Documentation/devicetree/bindings/sound/st,stm32-adfsdm.txt
new file mode 100644 (file)
index 0000000..864f5b0
--- /dev/null
@@ -0,0 +1,63 @@
+STMicroelectronics Audio Digital Filter Sigma Delta modulators(DFSDM)
+
+The DFSDM allows PDM microphones capture through SPI interface. The Audio
+interface is seems as a sub block of the DFSDM device.
+For details on DFSDM bindings refer to ../iio/adc/st,stm32-dfsdm-adc.txt
+
+Required properties:
+  - compatible: "st,stm32h7-dfsdm-dai".
+
+  - #sound-dai-cells : Must be equal to 0
+
+  - io-channels : phandle to iio dfsdm instance node.
+
+Example of a sound card using audio DFSDM node.
+
+       sound_card {
+               compatible = "audio-graph-card";
+
+               dais = <&cpu_port>;
+       };
+
+       dfsdm: dfsdm@40017000 {
+               compatible = "st,stm32h7-dfsdm";
+               reg = <0x40017000 0x400>;
+               clocks = <&rcc DFSDM1_CK>;
+               clock-names = "dfsdm";
+               #interrupt-cells = <1>;
+               #address-cells = <1>;
+               #size-cells = <0>;
+
+               dfsdm_adc0: filter@0 {
+                       compatible = "st,stm32-dfsdm-dmic";
+                       reg = <0>;
+                       interrupts = <110>;
+                       dmas = <&dmamux1 101 0x400 0x00>;
+                       dma-names = "rx";
+                       st,adc-channels = <1>;
+                       st,adc-channel-names = "dmic0";
+                       st,adc-channel-types = "SPI_R";
+                       st,adc-channel-clk-src = "CLKOUT";
+                       st,filter-order = <5>;
+
+                       dfsdm_dai0: dfsdm-dai {
+                               compatible = "st,stm32h7-dfsdm-dai";
+                               #sound-dai-cells = <0>;
+                               io-channels = <&dfsdm_adc0 0>;
+                               cpu_port: port {
+                               dfsdm_endpoint: endpoint {
+                                       remote-endpoint = <&dmic0_endpoint>;
+                               };
+                       };
+               };
+       };
+
+       dmic0: dmic@0 {
+               compatible = "dmic-codec";
+               #sound-dai-cells = <0>;
+               port {
+                       dmic0_endpoint: endpoint {
+                               remote-endpoint = <&dfsdm_endpoint>;
+                       };
+               };
+       };
index f2bb4feba3b67a03bbb9f4bdb5f9f8c7524282ee..633cdcfc933d0c8cc4b4bb3ed07ebbf7ea2cc710 100644 (file)
@@ -1332,10 +1332,13 @@ static int sgtl5000_i2c_probe(struct i2c_client *client,
        sgtl5000->mclk = devm_clk_get(&client->dev, NULL);
        if (IS_ERR(sgtl5000->mclk)) {
                ret = PTR_ERR(sgtl5000->mclk);
-               dev_err(&client->dev, "Failed to get mclock: %d\n", ret);
                /* Defer the probe to see if the clk will be provided later */
                if (ret == -ENOENT)
                        ret = -EPROBE_DEFER;
+
+               if (ret != -EPROBE_DEFER)
+                       dev_err(&client->dev, "Failed to get mclock: %d\n",
+                               ret);
                goto disable_regs;
        }
 
index 354dc0d64f11fbd29f59d324c8fd4fb9449acaee..7b91ee267b4eb24347e90c72894fb1daee3b6467 100644 (file)
@@ -231,14 +231,17 @@ static struct snd_soc_dai_driver si476x_dai = {
        .ops            = &si476x_dai_ops,
 };
 
-static struct regmap *si476x_get_regmap(struct device *dev)
+static int si476x_probe(struct snd_soc_component *component)
 {
-       return dev_get_regmap(dev->parent, NULL);
+       snd_soc_component_init_regmap(component,
+                               dev_get_regmap(component->dev->parent, NULL));
+
+       return 0;
 }
 
 static const struct snd_soc_codec_driver soc_codec_dev_si476x = {
-       .get_regmap = si476x_get_regmap,
        .component_driver = {
+               .probe                  = si476x_probe,
                .dapm_widgets           = si476x_dapm_widgets,
                .num_dapm_widgets       = ARRAY_SIZE(si476x_dapm_widgets),
                .dapm_routes            = si476x_dapm_routes,
index 7acd05140a810c53065186ce6aa6dfa22235c6f7..c8fd6367f6c00976e73108dfebcb41ad6cbafba7 100644 (file)
@@ -34,10 +34,11 @@ static const struct snd_soc_dapm_route dir_routes[] = {
 #define STUB_RATES     SNDRV_PCM_RATE_8000_192000
 #define STUB_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | \
                        SNDRV_PCM_FMTBIT_S20_3LE | \
-                       SNDRV_PCM_FMTBIT_S24_LE | \
+                       SNDRV_PCM_FMTBIT_S24_LE  | \
+                       SNDRV_PCM_FMTBIT_S32_LE | \
                        SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
 
-static const struct snd_soc_codec_driver soc_codec_spdif_dir = {
+static struct snd_soc_codec_driver soc_codec_spdif_dir = {
        .component_driver = {
                .dapm_widgets           = dir_widgets,
                .num_dapm_widgets       = ARRAY_SIZE(dir_widgets),
index 063a64ff82d3ed9c764f917b22f22ff291d3c3d1..037aa1d4555921e70b403a3d27706464d72b7633 100644 (file)
@@ -27,7 +27,8 @@
 #define STUB_RATES     SNDRV_PCM_RATE_8000_192000
 #define STUB_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | \
                        SNDRV_PCM_FMTBIT_S20_3LE | \
-                       SNDRV_PCM_FMTBIT_S24_LE)
+                       SNDRV_PCM_FMTBIT_S24_LE  | \
+                       SNDRV_PCM_FMTBIT_S32_LE)
 
 static const struct snd_soc_dapm_widget dit_widgets[] = {
        SND_SOC_DAPM_OUTPUT("spdif-out"),
@@ -37,7 +38,7 @@ static const struct snd_soc_dapm_route dit_routes[] = {
        { "spdif-out", NULL, "Playback" },
 };
 
-static const struct snd_soc_codec_driver soc_codec_spdif_dit = {
+static struct snd_soc_codec_driver soc_codec_spdif_dit = {
        .component_driver = {
                .dapm_widgets           = dit_widgets,
                .num_dapm_widgets       = ARRAY_SIZE(dit_widgets),
index 3398e6c57f37d3d05be0fbc962ea59c87e2cdb28..3ad881fc40a16173bec38808d9b6819df9e23557 100644 (file)
@@ -28,4 +28,16 @@ config SND_SOC_STM32_SPDIFRX
        help
          Say Y if you want to enable S/PDIF capture for STM32
 
+config SND_SOC_STM32_DFSDM
+       tristate "SoC Audio support for STM32 DFSDM"
+       depends on ARCH_STM32 || COMPILE_TEST
+       depends on SND_SOC
+       depends on STM32_DFSDM_ADC
+       select SND_SOC_GENERIC_DMAENGINE_PCM
+       select SND_SOC_DMIC
+       select IIO_BUFFER_CB
+       help
+         Select this option to enable the STM32 Digital Filter
+         for Sigma Delta Modulators (DFSDM) driver used
+         in various STM32 series for digital microphone capture.
 endmenu
index 5b7f0fab0bd60740e70a8d28270e728520db28e8..3143c0b4704263655108de9c88398c6c3c459604 100644 (file)
@@ -13,3 +13,6 @@ obj-$(CONFIG_SND_SOC_STM32_I2S) += snd-soc-stm32-i2s.o
 # SPDIFRX
 snd-soc-stm32-spdifrx-objs := stm32_spdifrx.o
 obj-$(CONFIG_SND_SOC_STM32_SPDIFRX) += snd-soc-stm32-spdifrx.o
+
+#DFSDM
+obj-$(CONFIG_SND_SOC_STM32_DFSDM) += stm32_adfsdm.o
diff --git a/sound/soc/stm/stm32_adfsdm.c b/sound/soc/stm/stm32_adfsdm.c
new file mode 100644 (file)
index 0000000..7306e3e
--- /dev/null
@@ -0,0 +1,347 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * This file is part of STM32 DFSDM ASoC DAI driver
+ *
+ * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
+ * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
+ *          Olivier Moysan <olivier.moysan@st.com>
+ */
+
+#include <linux/clk.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/consumer.h>
+#include <linux/iio/adc/stm32-dfsdm-adc.h>
+
+#include <sound/pcm.h>
+#include <sound/soc.h>
+
+#define STM32_ADFSDM_DRV_NAME "stm32-adfsdm"
+
+#define DFSDM_MAX_PERIOD_SIZE  (PAGE_SIZE / 2)
+#define DFSDM_MAX_PERIODS      6
+
+struct stm32_adfsdm_priv {
+       struct snd_soc_dai_driver dai_drv;
+       struct snd_pcm_substream *substream;
+       struct device *dev;
+
+       /* IIO */
+       struct iio_channel *iio_ch;
+       struct iio_cb_buffer *iio_cb;
+       bool iio_active;
+
+       /* PCM buffer */
+       unsigned char *pcm_buff;
+       unsigned int pos;
+};
+
+static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = {
+       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
+           SNDRV_PCM_INFO_PAUSE,
+       .formats = SNDRV_PCM_FMTBIT_S32_LE,
+
+       .rate_min = 8000,
+       .rate_max = 32000,
+
+       .channels_min = 1,
+       .channels_max = 1,
+
+       .periods_min = 2,
+       .periods_max = DFSDM_MAX_PERIODS,
+
+       .period_bytes_max = DFSDM_MAX_PERIOD_SIZE,
+       .buffer_bytes_max = DFSDM_MAX_PERIODS * DFSDM_MAX_PERIOD_SIZE
+};
+
+static void stm32_adfsdm_shutdown(struct snd_pcm_substream *substream,
+                                 struct snd_soc_dai *dai)
+{
+       struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
+
+       if (priv->iio_active) {
+               iio_channel_stop_all_cb(priv->iio_cb);
+               priv->iio_active = false;
+       }
+}
+
+static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
+                                   struct snd_soc_dai *dai)
+{
+       struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
+       int ret;
+
+       ret = iio_write_channel_attribute(priv->iio_ch,
+                                         substream->runtime->rate, 0,
+                                         IIO_CHAN_INFO_SAMP_FREQ);
+       if (ret < 0) {
+               dev_err(dai->dev, "%s: Failed to set %d sampling rate\n",
+                       __func__, substream->runtime->rate);
+               return ret;
+       }
+
+       if (!priv->iio_active) {
+               ret = iio_channel_start_all_cb(priv->iio_cb);
+               if (!ret)
+                       priv->iio_active = true;
+               else
+                       dev_err(dai->dev, "%s: IIO channel start failed (%d)\n",
+                               __func__, ret);
+       }
+
+       return ret;
+}
+
+static int stm32_adfsdm_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                                  unsigned int freq, int dir)
+{
+       struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
+       ssize_t size;
+       char str_freq[10];
+
+       dev_dbg(dai->dev, "%s: Enter for freq %d\n", __func__, freq);
+
+       /* Set IIO frequency if CODEC is master as clock comes from SPI_IN */
+
+       snprintf(str_freq, sizeof(str_freq), "%d\n", freq);
+       size = iio_write_channel_ext_info(priv->iio_ch, "spi_clk_freq",
+                                         str_freq, sizeof(str_freq));
+       if (size != sizeof(str_freq)) {
+               dev_err(dai->dev, "%s: Failed to set SPI clock\n",
+                       __func__);
+               return -EINVAL;
+       }
+       return 0;
+}
+
+static const struct snd_soc_dai_ops stm32_adfsdm_dai_ops = {
+       .shutdown = stm32_adfsdm_shutdown,
+       .prepare = stm32_adfsdm_dai_prepare,
+       .set_sysclk = stm32_adfsdm_set_sysclk,
+};
+
+static const struct snd_soc_dai_driver stm32_adfsdm_dai = {
+       .capture = {
+                   .channels_min = 1,
+                   .channels_max = 1,
+                   .formats = SNDRV_PCM_FMTBIT_S32_LE,
+                   .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
+                             SNDRV_PCM_RATE_32000),
+                   },
+       .ops = &stm32_adfsdm_dai_ops,
+};
+
+static const struct snd_soc_component_driver stm32_adfsdm_dai_component = {
+       .name = "stm32_dfsdm_audio",
+};
+
+static int stm32_afsdm_pcm_cb(const void *data, size_t size, void *private)
+{
+       struct stm32_adfsdm_priv *priv = private;
+       struct snd_soc_pcm_runtime *rtd = priv->substream->private_data;
+       u8 *pcm_buff = priv->pcm_buff;
+       u8 *src_buff = (u8 *)data;
+       unsigned int buff_size = snd_pcm_lib_buffer_bytes(priv->substream);
+       unsigned int period_size = snd_pcm_lib_period_bytes(priv->substream);
+       unsigned int old_pos = priv->pos;
+       unsigned int cur_size = size;
+
+       dev_dbg(rtd->dev, "%s: buff_add :%p, pos = %d, size = %zu\n",
+               __func__, &pcm_buff[priv->pos], priv->pos, size);
+
+       if ((priv->pos + size) > buff_size) {
+               memcpy(&pcm_buff[priv->pos], src_buff, buff_size - priv->pos);
+               cur_size -= buff_size - priv->pos;
+               priv->pos = 0;
+       }
+
+       memcpy(&pcm_buff[priv->pos], &src_buff[size - cur_size], cur_size);
+       priv->pos = (priv->pos + cur_size) % buff_size;
+
+       if (cur_size != size || (old_pos && (old_pos % period_size < size)))
+               snd_pcm_period_elapsed(priv->substream);
+
+       return 0;
+}
+
+static int stm32_adfsdm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct stm32_adfsdm_priv *priv =
+               snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+       switch (cmd) {
+       case SNDRV_PCM_TRIGGER_START:
+       case SNDRV_PCM_TRIGGER_RESUME:
+               priv->pos = 0;
+               return stm32_dfsdm_get_buff_cb(priv->iio_ch->indio_dev,
+                                              stm32_afsdm_pcm_cb, priv);
+       case SNDRV_PCM_TRIGGER_SUSPEND:
+       case SNDRV_PCM_TRIGGER_STOP:
+               return stm32_dfsdm_release_buff_cb(priv->iio_ch->indio_dev);
+       }
+
+       return -EINVAL;
+}
+
+static int stm32_adfsdm_pcm_open(struct snd_pcm_substream *substream)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+       int ret;
+
+       ret =  snd_soc_set_runtime_hwparams(substream, &stm32_adfsdm_pcm_hw);
+       if (!ret)
+               priv->substream = substream;
+
+       return ret;
+}
+
+static int stm32_adfsdm_pcm_close(struct snd_pcm_substream *substream)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct stm32_adfsdm_priv *priv =
+               snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+       snd_pcm_lib_free_pages(substream);
+       priv->substream = NULL;
+
+       return 0;
+}
+
+static snd_pcm_uframes_t stm32_adfsdm_pcm_pointer(
+                                           struct snd_pcm_substream *substream)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct stm32_adfsdm_priv *priv =
+               snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+       return bytes_to_frames(substream->runtime, priv->pos);
+}
+
+static int stm32_adfsdm_pcm_hw_params(struct snd_pcm_substream *substream,
+                                     struct snd_pcm_hw_params *params)
+{
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct stm32_adfsdm_priv *priv =
+               snd_soc_dai_get_drvdata(rtd->cpu_dai);
+       int ret;
+
+       ret =  snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
+       if (ret < 0)
+               return ret;
+       priv->pcm_buff = substream->runtime->dma_area;
+
+       return iio_channel_cb_set_buffer_watermark(priv->iio_cb,
+                                                  params_period_size(params));
+}
+
+static int stm32_adfsdm_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+       snd_pcm_lib_free_pages(substream);
+
+       return 0;
+}
+
+static struct snd_pcm_ops stm32_adfsdm_pcm_ops = {
+       .open           = stm32_adfsdm_pcm_open,
+       .close          = stm32_adfsdm_pcm_close,
+       .hw_params      = stm32_adfsdm_pcm_hw_params,
+       .hw_free        = stm32_adfsdm_pcm_hw_free,
+       .trigger        = stm32_adfsdm_trigger,
+       .pointer        = stm32_adfsdm_pcm_pointer,
+};
+
+static int stm32_adfsdm_pcm_new(struct snd_soc_pcm_runtime *rtd)
+{
+       struct snd_pcm *pcm = rtd->pcm;
+       struct stm32_adfsdm_priv *priv =
+               snd_soc_dai_get_drvdata(rtd->cpu_dai);
+       unsigned int size = DFSDM_MAX_PERIODS * DFSDM_MAX_PERIOD_SIZE;
+
+       return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                                    priv->dev, size, size);
+}
+
+static void stm32_adfsdm_pcm_free(struct snd_pcm *pcm)
+{
+       struct snd_pcm_substream *substream;
+       struct snd_soc_pcm_runtime *rtd;
+       struct stm32_adfsdm_priv *priv;
+
+       substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
+       if (substream) {
+               rtd = substream->private_data;
+               priv = snd_soc_dai_get_drvdata(rtd->cpu_dai);
+
+               snd_pcm_lib_preallocate_free_for_all(pcm);
+       }
+}
+
+static struct snd_soc_platform_driver stm32_adfsdm_soc_platform = {
+       .ops            = &stm32_adfsdm_pcm_ops,
+       .pcm_new        = stm32_adfsdm_pcm_new,
+       .pcm_free       = stm32_adfsdm_pcm_free,
+};
+
+static const struct of_device_id stm32_adfsdm_of_match[] = {
+       {.compatible = "st,stm32h7-dfsdm-dai"},
+       {}
+};
+MODULE_DEVICE_TABLE(of, stm32_adfsdm_of_match);
+
+static int stm32_adfsdm_probe(struct platform_device *pdev)
+{
+       struct stm32_adfsdm_priv *priv;
+       int ret;
+
+       priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->dev = &pdev->dev;
+       priv->dai_drv = stm32_adfsdm_dai;
+
+       dev_set_drvdata(&pdev->dev, priv);
+
+       ret = devm_snd_soc_register_component(&pdev->dev,
+                                             &stm32_adfsdm_dai_component,
+                                             &priv->dai_drv, 1);
+       if (ret < 0)
+               return ret;
+
+       /* Associate iio channel */
+       priv->iio_ch  = devm_iio_channel_get_all(&pdev->dev);
+       if (IS_ERR(priv->iio_ch))
+               return PTR_ERR(priv->iio_ch);
+
+       priv->iio_cb = iio_channel_get_all_cb(&pdev->dev, NULL, NULL);
+       if (IS_ERR(priv->iio_cb))
+               return PTR_ERR(priv->iio_cb);
+
+       ret = devm_snd_soc_register_platform(&pdev->dev,
+                                            &stm32_adfsdm_soc_platform);
+       if (ret < 0)
+               dev_err(&pdev->dev, "%s: Failed to register PCM platform\n",
+                       __func__);
+
+       return ret;
+}
+
+static struct platform_driver stm32_adfsdm_driver = {
+       .driver = {
+                  .name = STM32_ADFSDM_DRV_NAME,
+                  .of_match_table = stm32_adfsdm_of_match,
+                  },
+       .probe = stm32_adfsdm_probe,
+};
+
+module_platform_driver(stm32_adfsdm_driver);
+
+MODULE_DESCRIPTION("stm32 DFSDM DAI driver");
+MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" STM32_ADFSDM_DRV_NAME);