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
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index 061c465..f3fe64e 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -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 diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index abe2d7e..249ef0d 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -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 diff --git a/sound/soc/codecs/sti-sas.c b/sound/soc/codecs/sti-sas.c new file mode 100644 index 0000000..e3448a0 --- /dev/null +++ b/sound/soc/codecs/sti-sas.c @@ -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"); diff --git a/sound/soc/sti/Kconfig b/sound/soc/sti/Kconfig index c29e219..af5d6fd 100644 --- a/sound/soc/sti/Kconfig +++ b/sound/soc/sti/Kconfig @@ -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 \ No newline at end of file