@@ -102,6 +102,7 @@ config SND_SOC_ALL_CODECS
select SND_SOC_STA350 if I2C
select SND_SOC_STA529 if I2C
select SND_SOC_STAC9766 if SND_SOC_AC97_BUS
+ select SND_SOC_STI_SAS
select SND_SOC_TAS2552 if I2C
select SND_SOC_TAS5086 if I2C
select SND_SOC_TFA9879 if I2C
@@ -603,6 +604,9 @@ config SND_SOC_STA529
config SND_SOC_STAC9766
tristate
+config SND_SOC_STI_SAS
+ tristate
+
config SND_SOC_TAS2552
tristate "Texas Instruments TAS2552 Mono Audio amplifier"
depends on I2C
@@ -105,6 +105,7 @@ snd-soc-sta32x-objs := sta32x.o
snd-soc-sta350-objs := sta350.o
snd-soc-sta529-objs := sta529.o
snd-soc-stac9766-objs := stac9766.o
+snd-soc-sti-sas-objs := sti-sas.o
snd-soc-tas5086-objs := tas5086.o
snd-soc-tfa9879-objs := tfa9879.o
snd-soc-tlv320aic23-objs := tlv320aic23.o
@@ -286,6 +287,7 @@ obj-$(CONFIG_SND_SOC_STA32X) += snd-soc-sta32x.o
obj-$(CONFIG_SND_SOC_STA350) += snd-soc-sta350.o
obj-$(CONFIG_SND_SOC_STA529) += snd-soc-sta529.o
obj-$(CONFIG_SND_SOC_STAC9766) += snd-soc-stac9766.o
+obj-$(CONFIG_SND_SOC_STI_SAS) += snd-soc-sti-sas.o
obj-$(CONFIG_SND_SOC_TAS2552) += snd-soc-tas2552.o
obj-$(CONFIG_SND_SOC_TAS5086) += snd-soc-tas5086.o
obj-$(CONFIG_SND_SOC_TFA9879) += snd-soc-tfa9879.o
new file mode 100644
@@ -0,0 +1,663 @@
+/*
+ * Copyright (C) STMicroelectronics SA 2015
+ * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
+ * for STMicroelectronics.
+ * License terms: GNU General Public License (GPL), version 2
+ */
+
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/reset.h>
+#include <linux/mfd/syscon.h>
+
+#include <sound/soc.h>
+
+/* chipID supported */
+#define CHIPID_STIH416 0
+#define CHIPID_STIH407 1
+
+/* DAC definitions */
+/* stih416 DAC registers */
+/* sysconf 2517: Audio-DAC-Control */
+#define STIH416_AUDIO_DAC_CTRL 0x00000814
+/* sysconf 2519: Audio-Gue-Control */
+#define STIH416_AUDIO_GLUE_CTRL 0x0000081C
+
+/* stih407 DAC registers */
+/* sysconf 5041: Audio-Gue-Control */
+#define STIH407_AUDIO_GLUE_CTRL 0x000000A4
+/* sysconf 5042: Audio-DAC-Control */
+#define STIH407_AUDIO_DAC_CTRL 0x000000A8
+
+#define STI_DAC_MIN_CHANNELS 2
+#define STI_DAC_MAX_CHANNELS 2
+
+/* SPDIF definitions */
+#define STI_SPDIF_MIN_CHANNELS 2
+#define STI_SPDIF_MAX_CHANNELS 2
+
+static const struct of_device_id sti_sas_codec_drv_match[];
+
+enum {
+ STI_SAS_DAI_SPDIF_OUT,
+ STI_SAS_DAI_ANALOG_OUT,
+};
+
+enum {
+ BIPHASE_ENABLE,
+ BIPHASE_IDLE,
+ STI_SPDIF_MAX_RF
+};
+
+enum {
+ STIH416_DAC_MODE,
+ STIH416_DAC_NOT_STANDBY,
+ STIH416_DAC_SOFTMUTE,
+ STIH416_DAC_ANALOG_PWR_DW,
+ STIH416_DAC_ANALOG_NOT_PWR_DW_BG,
+ STIH416_DAC_MAX_RF
+};
+
+enum {
+ STIH407_DAC_SOFTMUTE,
+ STIH407_DAC_STANDBY_ANA,
+ STIH407_DAC_STANDBY,
+ STIH407_DAC_MAX_RF
+};
+
+struct codec_regfield {
+ struct regmap_field *field;
+ const struct reg_field regfield;
+};
+
+/* dac configuration fields */
+static struct codec_regfield sti_sas_dac_stih416[STIH416_DAC_MAX_RF] = {
+ /*STIH416_DAC_MODE*/
+ {NULL, REG_FIELD(STIH416_AUDIO_DAC_CTRL, 1, 2)},
+ /*STIH416_DAC_NOT_STANDBY */
+ {NULL, REG_FIELD(STIH416_AUDIO_DAC_CTRL, 3, 3)},
+ /*STIH416_DAC_SOFTMUTE*/
+ {NULL, REG_FIELD(STIH416_AUDIO_DAC_CTRL, 4, 4)},
+ /*STIH416_DAC_ANALOG_PWR_DW*/
+ {NULL, REG_FIELD(STIH416_AUDIO_DAC_CTRL, 5, 5)},
+ /*STIH416_DAC_ANALOG_NOT_PWR_DW_BG*/
+ {NULL, REG_FIELD(STIH416_AUDIO_DAC_CTRL, 6, 6)},
+};
+
+static struct codec_regfield sti_sas_dac_stih407[STIH407_DAC_MAX_RF] = {
+ /*STIH407_DAC_SOFTMUTE*/
+ {NULL, REG_FIELD(STIH407_AUDIO_DAC_CTRL, 0, 0)},
+ /*STIH407_DAC_STANDBY_ANA*/
+ {NULL, REG_FIELD(STIH407_AUDIO_DAC_CTRL, 1, 1)},
+ /*STIH407_DAC_STANDBY */
+ {NULL, REG_FIELD(STIH407_AUDIO_DAC_CTRL, 2, 2)},
+};
+
+/* SPDIF configuration fields */
+static struct codec_regfield sti_sas_spdif_stih416[STI_SPDIF_MAX_RF] = {
+ /*BIPHASE_ENABLE */
+ {NULL, REG_FIELD(STIH416_AUDIO_GLUE_CTRL, 6, 6)},
+ /*BIPHASE_IDLE*/
+ {NULL, REG_FIELD(STIH416_AUDIO_GLUE_CTRL, 7, 7)},
+};
+
+static struct codec_regfield sti_sas_spdif_stih407[STI_SPDIF_MAX_RF] = {
+ /*BIPHASE_ENABLE */
+ {NULL, REG_FIELD(STIH407_AUDIO_GLUE_CTRL, 6, 6)},
+ /*BIPHASE_IDLE*/
+ {NULL, REG_FIELD(STIH407_AUDIO_GLUE_CTRL, 7, 7)},
+};
+
+/* specify ops depends on codec version */
+struct sti_codec_ops {
+ int (*dai_dac_probe)(struct snd_soc_dai *dai);
+ int (*mute)(struct snd_soc_dai *dai, int mute);
+ int (*startup)(struct snd_soc_dai *);
+ void (*shutdown)(struct snd_soc_dai *);
+};
+
+struct sti_dac_audio {
+ const struct sti_codec_ops *ops;
+ struct regmap *regmap;
+ struct codec_regfield *regfield;
+ struct reset_control *rst;
+};
+
+struct sti_spdif_audio {
+ struct regmap *regmap;
+ struct codec_regfield *regfield;
+ struct reset_control *rst;
+};
+
+int sti_sas_dai_clk_div[];
+
+struct sti_sas_codec_data {
+ const int chipid;
+ struct device *dev;
+ struct sti_dac_audio dac;
+ struct sti_spdif_audio spdif;
+};
+
+static void sti_sas_map_sas_registers(struct sti_sas_codec_data *data)
+{
+ struct sti_spdif_audio *spdif = &data->spdif;
+ struct sti_dac_audio *dac = &data->dac;
+ int i, max_rf;
+
+ /* Get spdif regmap fields */
+ for (i = 0; i < STI_SPDIF_MAX_RF; i++)
+ spdif->regfield[i].field =
+ regmap_field_alloc(spdif->regmap,
+ spdif->regfield[i].regfield);
+ /* Get DAC regmap fields */
+ if (data->chipid == CHIPID_STIH407)
+ max_rf = STIH407_DAC_MAX_RF;
+ else
+ max_rf = STIH416_DAC_MAX_RF;
+ for (i = 0; i < max_rf; i++)
+ dac->regfield[i].field =
+ regmap_field_alloc(dac->regmap,
+ dac->regfield[i].regfield);
+}
+
+static int sti_sas_init_sas_registers(struct device *dev,
+ struct sti_sas_codec_data *data)
+{
+ struct sti_spdif_audio *spdif = &data->spdif;
+ struct sti_dac_audio *dac = &data->dac;
+ int ret;
+ /*
+ * DAC and SPDIF are activated by default
+ * put them in IDLE to save power
+ */
+
+ /* Initialise bi-phase formatter to disabled */
+ ret = regmap_field_write(spdif->regfield[BIPHASE_ENABLE].field, 0);
+
+ /* Initialise bi-phase formatter idle value to 0 */
+ ret |= regmap_field_write(spdif->regfield[BIPHASE_IDLE].field, 0);
+ if (ret < 0) {
+ dev_err(dev, "Failed to update SPDIF registers");
+ return ret;
+ }
+
+ /* init DAC configuration */
+ if (data->chipid == CHIPID_STIH407) {
+ /* init configuration */
+ ret = regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY].field, 1);
+ ret |= regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY_ANA].field, 1);
+ ret |= regmap_field_write(
+ dac->regfield[STIH407_DAC_SOFTMUTE].field, 1);
+ } else if (data->chipid == CHIPID_STIH416) {
+ ret = regmap_field_write(
+ dac->regfield[STIH416_DAC_NOT_STANDBY].field, 0);
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_PWR_DW].field, 0);
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_NOT_PWR_DW_BG].field,
+ 0);
+ }
+
+ if (ret < 0) {
+ dev_err(dev, "Failed to update DAC registers");
+ return ret;
+ }
+
+ return ret;
+}
+
+/*
+ * DAC
+ */
+static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+ /* Sanity check only */
+ if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
+ dev_err(dai->codec->dev,
+ "%s: ERROR: Unsupporter master mask 0x%x\n",
+ __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int stih416_dac_probe(struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ /* get reset control */
+ dac->rst = devm_reset_control_get(codec->dev, "dac_rst");
+ if (IS_ERR(dac->rst)) {
+ dev_err(dai->codec->dev,
+ "%s: ERROR: DAC reset not declared in DT (%d)!\n",
+ __func__, (int)dac->rst);
+ return -EFAULT;
+ }
+ /* put the DAC into reset */
+ reset_control_assert(dac->rst);
+
+ return 0;
+}
+
+int stih416_sas_dac_startup(struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+ int ret;
+
+ /* mute */
+ ret = regmap_field_write(
+ dac->regfield[STIH416_DAC_SOFTMUTE].field, 1);
+
+ /* Enable analog */
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_NOT_PWR_DW_BG].field, 1);
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_PWR_DW].field, 1);
+
+ /* Disable standby */
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_NOT_STANDBY].field, 1);
+
+ /* Take the DAC out of reset */
+ reset_control_deassert(dac->rst);
+
+ return ret;
+}
+
+int stih407_sas_dac_startup(struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+ int ret;
+
+ /* mute */
+ ret = regmap_field_write(
+ dac->regfield[STIH407_DAC_SOFTMUTE].field, 1);
+
+ /* Enable analog */
+ ret |= regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY_ANA].field, 0);
+
+ /* Disable standby */
+ ret |= regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY].field, 0);
+
+ return ret;
+}
+
+int sti_sas_dac_startup(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ if (dac->ops->startup)
+ return dac->ops->startup(dai);
+
+ return 0;
+}
+
+void stih416_sas_dac_shutdown(struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+ int ret;
+
+ /* put the DAC into reset */
+ reset_control_assert(dac->rst);
+
+ /* Enable standby */
+ ret = regmap_field_write(
+ dac->regfield[STIH416_DAC_NOT_STANDBY].field, 0);
+
+ /* Disable analog */
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_PWR_DW].field, 0);
+ ret |= regmap_field_write(
+ dac->regfield[STIH416_DAC_ANALOG_NOT_PWR_DW_BG].field, 0);
+ if (ret)
+ dev_err(codec->dev, "error while updating DAC registers\n");
+}
+
+static void stih407_sas_dac_shutdown(struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+ int ret;
+
+ /* Enable standby */
+ ret = regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY].field, 1);
+
+ /* Disable analog */
+ ret |= regmap_field_write(
+ dac->regfield[STIH407_DAC_STANDBY_ANA].field, 1);
+ if (ret)
+ dev_err(codec->dev, "error while updating DAC registers\n");
+}
+
+static void sti_sas_dac_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ if (dac->ops->shutdown)
+ dac->ops->shutdown(dai);
+}
+
+static int stih416_sas_dac_mute(struct snd_soc_dai *dai, int mute)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ if (mute)
+ return regmap_field_write(
+ dac->regfield[STIH416_DAC_SOFTMUTE].field, 1);
+ else
+ return regmap_field_write(
+ dac->regfield[STIH416_DAC_SOFTMUTE].field, 0);
+}
+
+static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ if (mute)
+ return regmap_field_write(
+ dac->regfield[STIH407_DAC_SOFTMUTE].field, 1);
+ else
+ return regmap_field_write(
+ dac->regfield[STIH407_DAC_SOFTMUTE].field, 0);
+}
+
+int sti_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_dac_audio *dac = &drvdata->dac;
+
+ if (dac->ops->mute)
+ return dac->ops->mute(dai, mute);
+
+ return 0;
+}
+
+struct sti_codec_ops stih416_ops = {
+ .dai_dac_probe = stih416_dac_probe,
+ .mute = stih416_sas_dac_mute,
+ .startup = stih416_sas_dac_startup,
+ .shutdown = stih416_sas_dac_shutdown,
+};
+
+struct sti_codec_ops stih407_ops = {
+ .mute = stih407_sas_dac_mute,
+ .startup = stih407_sas_dac_startup,
+ .shutdown = stih407_sas_dac_shutdown,
+};
+
+/*
+ * SPDIF
+ */
+static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
+ unsigned int fmt)
+{
+ if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
+ dev_err(dai->codec->dev,
+ "%s: ERROR: Unsupporter master mask 0x%x\n",
+ __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/*
+ * sti_sas_spdif_trigger
+ * Trigger function is used to ensure that BiPhase Formater is disabled
+ * before CPU dai is stopped.
+ * This is mandatory to avoid that BPF is stalled
+ */
+static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+ struct sti_spdif_audio *spdif = &drvdata->spdif;
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ return regmap_field_write(spdif->regfield[BIPHASE_ENABLE].field,
+ 1);
+ break;
+
+ case SNDRV_PCM_TRIGGER_RESUME:
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ case SNDRV_PCM_TRIGGER_STOP:
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ return regmap_field_write(spdif->regfield[BIPHASE_ENABLE].field,
+ 0);
+ break;
+ default:
+ return -EINVAL;
+ }
+}
+
+/*
+ * CODEC DAIS
+ */
+
+/*
+ * sti_sas_hw_params
+ * Request MCLK-FS clocks division to CPU_DAI based on requested rate
+ */
+static int sti_sas_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct snd_soc_pcm_runtime *rtd = substream->private_data;
+ struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+ int ret, div;
+
+ div = sti_sas_dai_clk_div[dai->id];
+ ret = snd_soc_dai_set_clkdiv(cpu_dai, SND_SOC_CLOCK_OUT, div);
+ if (ret)
+ dev_warn(codec->dev, "WARN: CPU DAI not support sysclk div");
+
+ return 0;
+}
+
+static struct snd_soc_dai_driver sti_sas_codec_dai[] = {
+ {
+ .name = "sas-dai-spdif-out",
+ .id = STI_SAS_DAI_SPDIF_OUT,
+ .playback = {
+ .stream_name = "spdif_p",
+ .channels_min = STI_SPDIF_MIN_CHANNELS,
+ .channels_max = STI_SPDIF_MAX_CHANNELS,
+ .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
+ SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
+ SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE |
+ SNDRV_PCM_FMTBIT_S32_LE,
+ },
+ .ops = (struct snd_soc_dai_ops[]) {
+ {
+ .set_fmt = sti_sas_spdif_set_fmt,
+ .trigger = sti_sas_spdif_trigger,
+ .hw_params = sti_sas_hw_params,
+ }
+ },
+ },
+ {
+ .name = "sas-dai-dac",
+ .id = STI_SAS_DAI_ANALOG_OUT,
+ .playback = {
+ .stream_name = "dac_p",
+ .channels_min = STI_DAC_MIN_CHANNELS,
+ .channels_max = STI_DAC_MAX_CHANNELS,
+ .rates = SNDRV_PCM_RATE_8000_48000,
+ .formats = SNDRV_PCM_FMTBIT_S16_LE |
+ SNDRV_PCM_FMTBIT_S32_LE,
+ },
+ .ops = (struct snd_soc_dai_ops[]) {
+ {
+ .set_fmt = sti_sas_dac_set_fmt,
+ .startup = sti_sas_dac_startup,
+ .shutdown = sti_sas_dac_shutdown,
+ .mute_stream = sti_sas_dac_mute,
+ .hw_params = sti_sas_hw_params,
+ }
+ },
+ },
+};
+
+int sti_sas_dai_clk_div[ARRAY_SIZE(sti_sas_codec_dai)] = {
+ 128, /* spdif out */
+ 256, /* dac */
+};
+
+#ifdef CONFIG_PM_SLEEP
+static int sti_sas_codec_suspend(struct snd_soc_codec *codec)
+{
+ /* Nothing done but need to be declared for PM management*/
+ return 0;
+}
+
+static int sti_sas_codec_resume(struct snd_soc_codec *codec)
+{
+ struct sti_sas_codec_data *drvdata = dev_get_drvdata(codec->dev);
+
+ return sti_sas_init_sas_registers(codec->dev, drvdata);
+}
+#else
+#define sti_sas_codec_suspend NULL
+#define sti_sas_codec_resume NULL
+#endif
+
+static struct snd_soc_codec_driver sti_sas_codec_driver = {
+ .suspend = sti_sas_codec_suspend,
+ .resume = sti_sas_codec_resume,
+};
+
+static int sti_sas_codec_driver_probe(struct platform_device *pdev)
+{
+ struct device_node *pnode = pdev->dev.of_node;
+ int status = 0;
+ struct sti_sas_codec_data *drvdata;
+
+ /* Allocate device structure */
+ drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_codec_data),
+ GFP_KERNEL);
+
+ if (!drvdata) {
+ dev_err(&pdev->dev, "Failed to allocate device structure");
+ return -ENOMEM;
+ }
+ /* Populate data structure depending on compatibility */
+ if (!of_match_node(sti_sas_codec_drv_match, pnode)->data) {
+ dev_err(&pdev->dev, "data associated to device is missing");
+ return -EINVAL;
+ }
+
+ memcpy(drvdata, of_match_node(sti_sas_codec_drv_match, pnode)->data,
+ sizeof(struct sti_sas_codec_data));
+
+ /* Initialise device structure */
+ drvdata->dev = &pdev->dev;
+
+ /* Request the DAC & SPDIF registers memory region */
+ drvdata->dac.regmap =
+ syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
+ if (!drvdata->dac.regmap) {
+ dev_err(&pdev->dev, "audio registers not enabled\n");
+ return -EFAULT;
+ }
+ drvdata->spdif.regmap = drvdata->dac.regmap;
+
+ sti_sas_map_sas_registers(drvdata);
+
+ status = sti_sas_init_sas_registers(&pdev->dev, drvdata);
+ if (status < 0)
+ return status;
+
+ /*Set DAC dai probe */
+ sti_sas_codec_dai[STI_SAS_DAI_ANALOG_OUT].probe =
+ drvdata->dac.ops->dai_dac_probe;
+
+ /*Store context */
+ dev_set_drvdata(&pdev->dev, drvdata);
+
+ status = snd_soc_register_codec(&pdev->dev, &sti_sas_codec_driver,
+ sti_sas_codec_dai,
+ ARRAY_SIZE(sti_sas_codec_dai));
+
+ return 0;
+}
+
+static int sti_sas_codec_driver_remove(struct platform_device *pdev)
+{
+ snd_soc_unregister_codec(&pdev->dev);
+
+ return 0;
+}
+
+const struct sti_sas_codec_data stih416_data = {
+ .chipid = CHIPID_STIH416,
+ .dac.ops = &stih416_ops,
+ .dac.regfield = sti_sas_dac_stih416,
+ .spdif.regfield = sti_sas_spdif_stih416,
+};
+
+const struct sti_sas_codec_data stih407_data = {
+ .chipid = CHIPID_STIH407,
+ .dac.ops = &stih407_ops,
+ .dac.regfield = sti_sas_dac_stih407,
+ .spdif.regfield = sti_sas_spdif_stih407,
+};
+
+static const struct of_device_id sti_sas_codec_drv_match[] = {
+ {
+ .compatible = "st,stih416-sas-codec",
+ .data = &stih416_data,
+ },
+ {
+ .compatible = "st,stih407-sas-codec",
+ .data = &stih407_data,
+ },
+ {},
+};
+
+static struct platform_driver sti_sas_codec_platform_driver = {
+ .driver = {
+ .name = "sti-sas-codec",
+ .owner = THIS_MODULE,
+ .of_match_table = sti_sas_codec_drv_match,
+ },
+ .probe = sti_sas_codec_driver_probe,
+ .remove = sti_sas_codec_driver_remove,
+};
+
+module_platform_driver(sti_sas_codec_platform_driver);
+
+MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
+MODULE_AUTHOR("Arnaud.pouliquen@st.com");
+MODULE_LICENSE("GPL");
@@ -9,3 +9,9 @@ menuconfig SND_SOC_STI
help
Say Y if you want to enable ASoC-support for
any of the STI platforms (e.g. STIH416).
+
+config SND_SOC_STI_SAS
+ tristate "codec Audio support for STI SAS codec"
+ depends on SND_SOC_STI
+ help
+ Say Y if you want to include STI SAS audio codec support
Codec part of the STi platform that support codec IPs. This first version does not support HDMI, but only DAC and SPDIF out. Signed-off-by: Arnaud Pouliquen <arnaud.pouliquen@st.com> --- sound/soc/codecs/Kconfig | 4 + sound/soc/codecs/Makefile | 2 + sound/soc/codecs/sti-sas.c | 663 +++++++++++++++++++++++++++++++++++++++++++++ sound/soc/sti/Kconfig | 6 + 4 files changed, 675 insertions(+) create mode 100644 sound/soc/codecs/sti-sas.c \ No newline at end of file