Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-23 12:42:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branches 'asoc/topic/adav80x', 'asoc/topic/ads117x', 'asoc/topic/ak4104', 'asoc/topic/ak4458' and 'asoc/topic/ak4535' into asoc-next

Browse Source
This commit is contained in:
Mark Brown 2018-03-28 10:28:43 +08:00
commit 5eed6fe345
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
11 changed files with 916 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Documentation/devicetree/bindings/sound/ak4458.txt Normal file
View File

@ -0,0 +1,23 @@
AK4458 audio DAC
This device supports I2C mode.
Required properties:
- compatible : "asahi-kasei,ak4458"
- reg : The I2C address of the device for I2C
Optional properties:
- reset-gpios: A GPIO specifier for the power down & reset pin
- mute-gpios: A GPIO specifier for the soft mute pin
Example:
&i2c {
ak4458: dac@10 {
compatible = "asahi-kasei,ak4458";
reg = <0x10>;
reset-gpios = <&gpio1 10 GPIO_ACTIVE_LOW>
mute-gpios = <&gpio1 11 GPIO_ACTIVE_HIGH>
};
};

6
sound/soc/codecs/Kconfig
View File

@ -35,6 +35,7 @@ config SND_SOC_ALL_CODECS
select SND_SOC_ADAU7002
select SND_SOC_ADS117X
select SND_SOC_AK4104 if SPI_MASTER
select SND_SOC_AK4458 if I2C
select SND_SOC_AK4535 if I2C
select SND_SOC_AK4554
select SND_SOC_AK4613 if I2C
@ -376,6 +377,11 @@ config SND_SOC_AK4104
tristate "AKM AK4104 CODEC"
depends on SPI_MASTER
config SND_SOC_AK4458
tristate "AKM AK4458 CODEC"
depends on I2C
select REGMAP_I2C
config SND_SOC_AK4535
tristate

2
sound/soc/codecs/Makefile
View File

@ -27,6 +27,7 @@ snd-soc-adav801-objs := adav801.o
snd-soc-adav803-objs := adav803.o
snd-soc-ads117x-objs := ads117x.o
snd-soc-ak4104-objs := ak4104.o
snd-soc-ak4458-objs := ak4458.o
snd-soc-ak4535-objs := ak4535.o
snd-soc-ak4554-objs := ak4554.o
snd-soc-ak4613-objs := ak4613.o
@ -272,6 +273,7 @@ obj-$(CONFIG_SND_SOC_ADAV801) += snd-soc-adav801.o
obj-$(CONFIG_SND_SOC_ADAV803) += snd-soc-adav803.o
obj-$(CONFIG_SND_SOC_ADS117X) += snd-soc-ads117x.o
obj-$(CONFIG_SND_SOC_AK4104) += snd-soc-ak4104.o
obj-$(CONFIG_SND_SOC_AK4458) += snd-soc-ak4458.o
obj-$(CONFIG_SND_SOC_AK4535) += snd-soc-ak4535.o
obj-$(CONFIG_SND_SOC_AK4554) += snd-soc-ak4554.o
obj-$(CONFIG_SND_SOC_AK4613) += snd-soc-ak4613.o

7
sound/soc/codecs/adav801.c
View File

@ -30,18 +30,11 @@ static int adav80x_spi_probe(struct spi_device *spi)
return adav80x_bus_probe(&spi->dev, devm_regmap_init_spi(spi, &config));
}
static int adav80x_spi_remove(struct spi_device *spi)
{
snd_soc_unregister_codec(&spi->dev);
return 0;
}
static struct spi_driver adav80x_spi_driver = {
.driver = {
.name = "adav801",
},
.probe = adav80x_spi_probe,
.remove = adav80x_spi_remove,
.id_table = adav80x_spi_id,
};
module_spi_driver(adav80x_spi_driver);

7
sound/soc/codecs/adav803.c
View File

@ -27,18 +27,11 @@ static int adav803_probe(struct i2c_client *client,
devm_regmap_init_i2c(client, &adav80x_regmap_config));
}
static int adav803_remove(struct i2c_client *client)
{
snd_soc_unregister_codec(&client->dev);
return 0;
}
static struct i2c_driver adav803_driver = {
.driver = {
.name = "adav803",
},
.probe = adav803_probe,
.remove = adav803_remove,
.id_table = adav803_id,
};
module_i2c_driver(adav803_driver);

130
sound/soc/codecs/adav80x.c
View File

@ -212,8 +212,8 @@ static const struct snd_soc_dapm_widget adav80x_dapm_widgets[] = {
static int adav80x_dapm_sysclk_check(struct snd_soc_dapm_widget *source,
struct snd_soc_dapm_widget *sink)
{
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = snd_soc_dapm_to_component(source->dapm);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
const char *clk;
switch (adav80x->clk_src) {
@ -236,8 +236,8 @@ static int adav80x_dapm_sysclk_check(struct snd_soc_dapm_widget *source,
static int adav80x_dapm_pll_check(struct snd_soc_dapm_widget *source,
struct snd_soc_dapm_widget *sink)
{
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = snd_soc_dapm_to_component(source->dapm);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
return adav80x->pll_src == ADAV80X_PLL_SRC_XTAL;
}
@ -281,9 +281,9 @@ static const struct snd_soc_dapm_route adav80x_dapm_routes[] = {
{ "AIFAUXIN", NULL, "SYSCLK" },
};
static int adav80x_set_deemph(struct snd_soc_codec *codec)
static int adav80x_set_deemph(struct snd_soc_component *component)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int val;
if (adav80x->deemph) {
@ -315,8 +315,8 @@ static int adav80x_set_deemph(struct snd_soc_codec *codec)
static int adav80x_put_deemph(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int deemph = ucontrol->value.integer.value[0];
if (deemph > 1)
@ -324,14 +324,14 @@ static int adav80x_put_deemph(struct snd_kcontrol *kcontrol,
adav80x->deemph = deemph;
return adav80x_set_deemph(codec);
return adav80x_set_deemph(component);
}
static int adav80x_get_deemph(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
ucontrol->value.integer.value[0] = adav80x->deemph;
return 0;
@ -365,8 +365,8 @@ static unsigned int adav80x_port_ctrl_regs[2][2] = {
static int adav80x_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
struct snd_soc_codec *codec = dai->codec;
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = dai->component;
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int capture = 0x00;
unsigned int playback = 0x00;
@ -415,10 +415,10 @@ static int adav80x_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
return 0;
}
static int adav80x_set_adc_clock(struct snd_soc_codec *codec,
static int adav80x_set_adc_clock(struct snd_soc_component *component,
unsigned int sample_rate)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int val;
if (sample_rate <= 48000)
@ -432,10 +432,10 @@ static int adav80x_set_adc_clock(struct snd_soc_codec *codec,
return 0;
}
static int adav80x_set_dac_clock(struct snd_soc_codec *codec,
static int adav80x_set_dac_clock(struct snd_soc_component *component,
unsigned int sample_rate)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int val;
if (sample_rate <= 48000)
@ -450,10 +450,10 @@ static int adav80x_set_dac_clock(struct snd_soc_codec *codec,
return 0;
}
static int adav80x_set_capture_pcm_format(struct snd_soc_codec *codec,
static int adav80x_set_capture_pcm_format(struct snd_soc_component *component,
struct snd_soc_dai *dai, struct snd_pcm_hw_params *params)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int val;
switch (params_width(params)) {
@ -479,10 +479,10 @@ static int adav80x_set_capture_pcm_format(struct snd_soc_codec *codec,
return 0;
}
static int adav80x_set_playback_pcm_format(struct snd_soc_codec *codec,
static int adav80x_set_playback_pcm_format(struct snd_soc_component *component,
struct snd_soc_dai *dai, struct snd_pcm_hw_params *params)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int val;
if (adav80x->dai_fmt[dai->id] != SND_SOC_DAIFMT_RIGHT_J)
@ -514,32 +514,32 @@ static int adav80x_set_playback_pcm_format(struct snd_soc_codec *codec,
static int adav80x_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 adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = dai->component;
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int rate = params_rate(params);
if (rate * 256 != adav80x->sysclk)
return -EINVAL;
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
adav80x_set_playback_pcm_format(codec, dai, params);
adav80x_set_dac_clock(codec, rate);
adav80x_set_playback_pcm_format(component, dai, params);
adav80x_set_dac_clock(component, rate);
} else {
adav80x_set_capture_pcm_format(codec, dai, params);
adav80x_set_adc_clock(codec, rate);
adav80x_set_capture_pcm_format(component, dai, params);
adav80x_set_adc_clock(component, rate);
}
adav80x->rate = rate;
adav80x_set_deemph(codec);
adav80x_set_deemph(component);
return 0;
}
static int adav80x_set_sysclk(struct snd_soc_codec *codec,
static int adav80x_set_sysclk(struct snd_soc_component *component,
int clk_id, int source,
unsigned int freq, int dir)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
if (dir == SND_SOC_CLOCK_IN) {
switch (clk_id) {
@ -619,11 +619,11 @@ static int adav80x_set_sysclk(struct snd_soc_codec *codec,
return 0;
}
static int adav80x_set_pll(struct snd_soc_codec *codec, int pll_id,
static int adav80x_set_pll(struct snd_soc_component *component, int pll_id,
int source, unsigned int freq_in, unsigned int freq_out)
{
struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int pll_ctrl1 = 0;
unsigned int pll_ctrl2 = 0;
unsigned int pll_src;
@ -694,10 +694,10 @@ static int adav80x_set_pll(struct snd_soc_codec *codec, int pll_id,
return 0;
}
static int adav80x_set_bias_level(struct snd_soc_codec *codec,
static int adav80x_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
unsigned int mask = ADAV80X_DAC_CTRL1_PD;
switch (level) {
@ -722,10 +722,10 @@ static int adav80x_set_bias_level(struct snd_soc_codec *codec,
static int adav80x_dai_startup(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct snd_soc_codec *codec = dai->codec;
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = dai->component;
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
if (!snd_soc_codec_is_active(codec) || !adav80x->rate)
if (!snd_soc_component_is_active(component) || !adav80x->rate)
return 0;
return snd_pcm_hw_constraint_single(substream->runtime,
@ -735,10 +735,10 @@ static int adav80x_dai_startup(struct snd_pcm_substream *substream,
static void adav80x_dai_shutdown(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct snd_soc_codec *codec = dai->codec;
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = dai->component;
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
if (!snd_soc_codec_is_active(codec))
if (!snd_soc_component_is_active(component))
adav80x->rate = 0;
}
@ -799,10 +799,10 @@ static struct snd_soc_dai_driver adav80x_dais[] = {
},
};
static int adav80x_probe(struct snd_soc_codec *codec)
static int adav80x_probe(struct snd_soc_component *component)
{
struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
/* Force PLLs on for SYSCLK output */
snd_soc_dapm_force_enable_pin(dapm, "PLL1");
@ -816,32 +816,32 @@ static int adav80x_probe(struct snd_soc_codec *codec)
return 0;
}
static int adav80x_resume(struct snd_soc_codec *codec)
static int adav80x_resume(struct snd_soc_component *component)
{
struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
struct adav80x *adav80x = snd_soc_component_get_drvdata(component);
regcache_sync(adav80x->regmap);
return 0;
}
static const struct snd_soc_codec_driver adav80x_codec_driver = {
.probe = adav80x_probe,
.resume = adav80x_resume,
.set_bias_level = adav80x_set_bias_level,
.suspend_bias_off = true,
.set_pll = adav80x_set_pll,
.set_sysclk = adav80x_set_sysclk,
.component_driver = {
.controls = adav80x_controls,
.num_controls = ARRAY_SIZE(adav80x_controls),
.dapm_widgets = adav80x_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(adav80x_dapm_widgets),
.dapm_routes = adav80x_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(adav80x_dapm_routes),
},
static const struct snd_soc_component_driver adav80x_component_driver = {
.probe = adav80x_probe,
.resume = adav80x_resume,
.set_bias_level = adav80x_set_bias_level,
.set_pll = adav80x_set_pll,
.set_sysclk = adav80x_set_sysclk,
.controls = adav80x_controls,
.num_controls = ARRAY_SIZE(adav80x_controls),
.dapm_widgets = adav80x_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(adav80x_dapm_widgets),
.dapm_routes = adav80x_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(adav80x_dapm_routes),
.suspend_bias_off = 1,
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
int adav80x_bus_probe(struct device *dev, struct regmap *regmap)
@ -858,7 +858,7 @@ int adav80x_bus_probe(struct device *dev, struct regmap *regmap)
dev_set_drvdata(dev, adav80x);
adav80x->regmap = regmap;
return snd_soc_register_codec(dev, &adav80x_codec_driver,
return devm_snd_soc_register_component(dev, &adav80x_component_driver,
adav80x_dais, ARRAY_SIZE(adav80x_dais));
}
EXPORT_SYMBOL_GPL(adav80x_bus_probe);

27
sound/soc/codecs/ads117x.c
View File

@ -58,25 +58,21 @@ static struct snd_soc_dai_driver ads117x_dai = {
.formats = ADS117X_FORMATS,},
};
static const struct snd_soc_codec_driver soc_codec_dev_ads117x = {
.component_driver = {
.dapm_widgets = ads117x_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ads117x_dapm_widgets),
.dapm_routes = ads117x_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(ads117x_dapm_routes),
},
static const struct snd_soc_component_driver soc_component_dev_ads117x = {
.dapm_widgets = ads117x_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ads117x_dapm_widgets),
.dapm_routes = ads117x_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(ads117x_dapm_routes),
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static int ads117x_probe(struct platform_device *pdev)
{
return snd_soc_register_codec(&pdev->dev,
&soc_codec_dev_ads117x, &ads117x_dai, 1);
}
static int ads117x_remove(struct platform_device *pdev)
{
snd_soc_unregister_codec(&pdev->dev);
return 0;
return devm_snd_soc_register_component(&pdev->dev,
&soc_component_dev_ads117x, &ads117x_dai, 1);
}
#if defined(CONFIG_OF)
@ -95,7 +91,6 @@ static struct platform_driver ads117x_codec_driver = {
},
.probe = ads117x_probe,
.remove = ads117x_remove,
};
module_platform_driver(ads117x_codec_driver);

68
sound/soc/codecs/ak4104.c
View File

@ -65,8 +65,8 @@ static const struct snd_soc_dapm_route ak4104_dapm_routes[] = {
static int ak4104_set_dai_fmt(struct snd_soc_dai *codec_dai,
unsigned int format)
{
struct snd_soc_codec *codec = codec_dai->codec;
struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = codec_dai->component;
struct ak4104_private *ak4104 = snd_soc_component_get_drvdata(component);
int val = 0;
int ret;
@ -81,7 +81,7 @@ static int ak4104_set_dai_fmt(struct snd_soc_dai *codec_dai,
val |= AK4104_CONTROL1_DIF0 | AK4104_CONTROL1_DIF1;
break;
default:
dev_err(codec->dev, "invalid dai format\n");
dev_err(component->dev, "invalid dai format\n");
return -EINVAL;
}
@ -102,8 +102,8 @@ static int ak4104_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 ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = dai->component;
struct ak4104_private *ak4104 = snd_soc_component_get_drvdata(component);
int ret, val = 0;
/* set the IEC958 bits: consumer mode, no copyright bit */
@ -141,7 +141,7 @@ static int ak4104_hw_params(struct snd_pcm_substream *substream,
val |= IEC958_AES3_CON_FS_192000;
break;
default:
dev_err(codec->dev, "unsupported sampling rate\n");
dev_err(component->dev, "unsupported sampling rate\n");
return -EINVAL;
}
@ -174,14 +174,14 @@ static struct snd_soc_dai_driver ak4104_dai = {
.ops = &ak4101_dai_ops,
};
static int ak4104_probe(struct snd_soc_codec *codec)
static int ak4104_probe(struct snd_soc_component *component)
{
struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
struct ak4104_private *ak4104 = snd_soc_component_get_drvdata(component);
int ret;
ret = regulator_enable(ak4104->regulator);
if (ret < 0) {
dev_err(codec->dev, "Unable to enable regulator: %d\n", ret);
dev_err(component->dev, "Unable to enable regulator: %d\n", ret);
return ret;
}
@ -205,30 +205,28 @@ exit_disable_regulator:
return ret;
}
static int ak4104_remove(struct snd_soc_codec *codec)
static void ak4104_remove(struct snd_soc_component *component)
{
struct ak4104_private *ak4104 = snd_soc_codec_get_drvdata(codec);
struct ak4104_private *ak4104 = snd_soc_component_get_drvdata(component);
regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1,
AK4104_CONTROL1_PW | AK4104_CONTROL1_RSTN, 0);
regulator_disable(ak4104->regulator);
return 0;
}
#ifdef CONFIG_PM
static int ak4104_soc_suspend(struct snd_soc_codec *codec)
static int ak4104_soc_suspend(struct snd_soc_component *component)
{
struct ak4104_private *priv = snd_soc_codec_get_drvdata(codec);
struct ak4104_private *priv = snd_soc_component_get_drvdata(component);
regulator_disable(priv->regulator);
return 0;
}
static int ak4104_soc_resume(struct snd_soc_codec *codec)
static int ak4104_soc_resume(struct snd_soc_component *component)
{
struct ak4104_private *priv = snd_soc_codec_get_drvdata(codec);
struct ak4104_private *priv = snd_soc_component_get_drvdata(component);
int ret;
ret = regulator_enable(priv->regulator);
@ -242,18 +240,19 @@ static int ak4104_soc_resume(struct snd_soc_codec *codec)
#define ak4104_soc_resume NULL
#endif /* CONFIG_PM */
static const struct snd_soc_codec_driver soc_codec_device_ak4104 = {
.probe = ak4104_probe,
.remove = ak4104_remove,
.suspend = ak4104_soc_suspend,
.resume = ak4104_soc_resume,
.component_driver = {
.dapm_widgets = ak4104_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ak4104_dapm_widgets),
.dapm_routes = ak4104_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(ak4104_dapm_routes),
}
static const struct snd_soc_component_driver soc_component_device_ak4104 = {
.probe = ak4104_probe,
.remove = ak4104_remove,
.suspend = ak4104_soc_suspend,
.resume = ak4104_soc_resume,
.dapm_widgets = ak4104_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ak4104_dapm_widgets),
.dapm_routes = ak4104_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(ak4104_dapm_routes),
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static const struct regmap_config ak4104_regmap = {
@ -323,17 +322,11 @@ static int ak4104_spi_probe(struct spi_device *spi)
spi_set_drvdata(spi, ak4104);
ret = snd_soc_register_codec(&spi->dev,
&soc_codec_device_ak4104, &ak4104_dai, 1);
ret = devm_snd_soc_register_component(&spi->dev,
&soc_component_device_ak4104, &ak4104_dai, 1);
return ret;
}
static int ak4104_spi_remove(struct spi_device *spi)
{
snd_soc_unregister_codec(&spi->dev);
return 0;
}
static const struct of_device_id ak4104_of_match[] = {
{ .compatible = "asahi-kasei,ak4104", },
{ }
@ -353,7 +346,6 @@ static struct spi_driver ak4104_spi_driver = {
},
.id_table = ak4104_id_table,
.probe = ak4104_spi_probe,
.remove = ak4104_spi_remove,
};
module_spi_driver(ak4104_spi_driver);

657
sound/soc/codecs/ak4458.c Normal file
View File

@ -0,0 +1,657 @@
// SPDX-License-Identifier: GPL-2.0
//
// Audio driver for AK4458 DAC
//
// Copyright (C) 2016 Asahi Kasei Microdevices Corporation
// Copyright 2018 NXP
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <sound/initval.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/tlv.h>
#include "ak4458.h"
/* AK4458 Codec Private Data */
struct ak4458_priv {
struct device *dev;
struct regmap *regmap;
struct gpio_desc *reset_gpiod;
struct gpio_desc *mute_gpiod;
int digfil; /* SSLOW, SD, SLOW bits */
int fs; /* sampling rate */
int fmt;
int slots;
int slot_width;
};
static const struct reg_default ak4458_reg_defaults[] = {
{ 0x00, 0x0C }, /* 0x00 AK4458_00_CONTROL1 */
{ 0x01, 0x22 }, /* 0x01 AK4458_01_CONTROL2 */
{ 0x02, 0x00 }, /* 0x02 AK4458_02_CONTROL3 */
{ 0x03, 0xFF }, /* 0x03 AK4458_03_LCHATT */
{ 0x04, 0xFF }, /* 0x04 AK4458_04_RCHATT */
{ 0x05, 0x00 }, /* 0x05 AK4458_05_CONTROL4 */
{ 0x06, 0x00 }, /* 0x06 AK4458_06_DSD1 */
{ 0x07, 0x03 }, /* 0x07 AK4458_07_CONTROL5 */
{ 0x08, 0x00 }, /* 0x08 AK4458_08_SOUND_CONTROL */
{ 0x09, 0x00 }, /* 0x09 AK4458_09_DSD2 */
{ 0x0A, 0x0D }, /* 0x0A AK4458_0A_CONTROL6 */
{ 0x0B, 0x0C }, /* 0x0B AK4458_0B_CONTROL7 */
{ 0x0C, 0x00 }, /* 0x0C AK4458_0C_CONTROL8 */
{ 0x0D, 0x00 }, /* 0x0D AK4458_0D_CONTROL9 */
{ 0x0E, 0x50 }, /* 0x0E AK4458_0E_CONTROL10 */
{ 0x0F, 0xFF }, /* 0x0F AK4458_0F_L2CHATT */
{ 0x10, 0xFF }, /* 0x10 AK4458_10_R2CHATT */
{ 0x11, 0xFF }, /* 0x11 AK4458_11_L3CHATT */
{ 0x12, 0xFF }, /* 0x12 AK4458_12_R3CHATT */
{ 0x13, 0xFF }, /* 0x13 AK4458_13_L4CHATT */
{ 0x14, 0xFF }, /* 0x14 AK4458_14_R4CHATT */
};
/*
* Volume control:
* from -127 to 0 dB in 0.5 dB steps (mute instead of -127.5 dB)
*/
static DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
/*
* DEM1 bit DEM0 bit Mode
* 0 0 44.1kHz
* 0 1 OFF (default)
* 1 0 48kHz
* 1 1 32kHz
*/
static const char * const ak4458_dem_select_texts[] = {
"44.1kHz", "OFF", "48kHz", "32kHz"
};
/*
* SSLOW, SD, SLOW bits Digital Filter Setting
* 0, 0, 0 : Sharp Roll-Off Filter
* 0, 0, 1 : Slow Roll-Off Filter
* 0, 1, 0 : Short delay Sharp Roll-Off Filter
* 0, 1, 1 : Short delay Slow Roll-Off Filter
* 1, *, * : Super Slow Roll-Off Filter
*/
static const char * const ak4458_digfil_select_texts[] = {
"Sharp Roll-Off Filter",
"Slow Roll-Off Filter",
"Short delay Sharp Roll-Off Filter",
"Short delay Slow Roll-Off Filter",
"Super Slow Roll-Off Filter"
};
/*
* DZFB: Inverting Enable of DZF
* 0: DZF goes H at Zero Detection
* 1: DZF goes L at Zero Detection
*/
static const char * const ak4458_dzfb_select_texts[] = {"H", "L"};
/*
* SC1-0 bits: Sound Mode Setting
* 0 0 : Sound Mode 0
* 0 1 : Sound Mode 1
* 1 0 : Sound Mode 2
* 1 1 : Reserved
*/
static const char * const ak4458_sc_select_texts[] = {
"Sound Mode 0", "Sound Mode 1", "Sound Mode 2"
};
/* FIR2-0 bits: FIR Filter Mode Setting */
static const char * const ak4458_fir_select_texts[] = {
"Mode 0", "Mode 1", "Mode 2", "Mode 3",
"Mode 4", "Mode 5", "Mode 6", "Mode 7",
};
/* ATS1-0 bits Attenuation Speed */
static const char * const ak4458_ats_select_texts[] = {
"4080/fs", "2040/fs", "510/fs", "255/fs",
};
/* DIF2 bit Audio Interface Format Setting(BICK fs) */
static const char * const ak4458_dif_select_texts[] = {"32fs,48fs", "64fs",};
static const struct soc_enum ak4458_dac1_dem_enum =
SOC_ENUM_SINGLE(AK4458_01_CONTROL2, 1,
ARRAY_SIZE(ak4458_dem_select_texts),
ak4458_dem_select_texts);
static const struct soc_enum ak4458_dac2_dem_enum =
SOC_ENUM_SINGLE(AK4458_0A_CONTROL6, 0,
ARRAY_SIZE(ak4458_dem_select_texts),
ak4458_dem_select_texts);
static const struct soc_enum ak4458_dac3_dem_enum =
SOC_ENUM_SINGLE(AK4458_0E_CONTROL10, 4,
ARRAY_SIZE(ak4458_dem_select_texts),
ak4458_dem_select_texts);
static const struct soc_enum ak4458_dac4_dem_enum =
SOC_ENUM_SINGLE(AK4458_0E_CONTROL10, 6,
ARRAY_SIZE(ak4458_dem_select_texts),
ak4458_dem_select_texts);
static const struct soc_enum ak4458_digfil_enum =
SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(ak4458_digfil_select_texts),
ak4458_digfil_select_texts);
static const struct soc_enum ak4458_dzfb_enum =
SOC_ENUM_SINGLE(AK4458_02_CONTROL3, 2,
ARRAY_SIZE(ak4458_dzfb_select_texts),
ak4458_dzfb_select_texts);
static const struct soc_enum ak4458_sm_enum =
SOC_ENUM_SINGLE(AK4458_08_SOUND_CONTROL, 0,
ARRAY_SIZE(ak4458_sc_select_texts),
ak4458_sc_select_texts);
static const struct soc_enum ak4458_fir_enum =
SOC_ENUM_SINGLE(AK4458_0C_CONTROL8, 0,
ARRAY_SIZE(ak4458_fir_select_texts),
ak4458_fir_select_texts);
static const struct soc_enum ak4458_ats_enum =
SOC_ENUM_SINGLE(AK4458_0B_CONTROL7, 6,
ARRAY_SIZE(ak4458_ats_select_texts),
ak4458_ats_select_texts);
static const struct soc_enum ak4458_dif_enum =
SOC_ENUM_SINGLE(AK4458_00_CONTROL1, 3,
ARRAY_SIZE(ak4458_dif_select_texts),
ak4458_dif_select_texts);
static int get_digfil(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
ucontrol->value.enumerated.item[0] = ak4458->digfil;
return 0;
}
static int set_digfil(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
int num;
num = ucontrol->value.enumerated.item[0];
if (num > 4)
return -EINVAL;
ak4458->digfil = num;
/* write SD bit */
snd_soc_component_update_bits(component, AK4458_01_CONTROL2,
AK4458_SD_MASK,
((ak4458->digfil & 0x02) << 4));
/* write SLOW bit */
snd_soc_component_update_bits(component, AK4458_02_CONTROL3,
AK4458_SLOW_MASK,
(ak4458->digfil & 0x01));
/* write SSLOW bit */
snd_soc_component_update_bits(component, AK4458_05_CONTROL4,
AK4458_SSLOW_MASK,
((ak4458->digfil & 0x04) >> 2));
return 0;
}
static const struct snd_kcontrol_new ak4458_snd_controls[] = {
SOC_DOUBLE_R_TLV("DAC1 Playback Volume", AK4458_03_LCHATT,
AK4458_04_RCHATT, 0, 0xFF, 0, dac_tlv),
SOC_DOUBLE_R_TLV("DAC2 Playback Volume", AK4458_0F_L2CHATT,
AK4458_10_R2CHATT, 0, 0xFF, 0, dac_tlv),
SOC_DOUBLE_R_TLV("DAC3 Playback Volume", AK4458_11_L3CHATT,
AK4458_12_R3CHATT, 0, 0xFF, 0, dac_tlv),
SOC_DOUBLE_R_TLV("DAC4 Playback Volume", AK4458_13_L4CHATT,
AK4458_14_R4CHATT, 0, 0xFF, 0, dac_tlv),
SOC_ENUM("AK4458 De-emphasis Response DAC1", ak4458_dac1_dem_enum),
SOC_ENUM("AK4458 De-emphasis Response DAC2", ak4458_dac2_dem_enum),
SOC_ENUM("AK4458 De-emphasis Response DAC3", ak4458_dac3_dem_enum),
SOC_ENUM("AK4458 De-emphasis Response DAC4", ak4458_dac4_dem_enum),
SOC_ENUM_EXT("AK4458 Digital Filter Setting", ak4458_digfil_enum,
get_digfil, set_digfil),
SOC_ENUM("AK4458 Inverting Enable of DZFB", ak4458_dzfb_enum),
SOC_ENUM("AK4458 Sound Mode", ak4458_sm_enum),
SOC_ENUM("AK4458 FIR Filter Mode Setting", ak4458_fir_enum),
SOC_ENUM("AK4458 Attenuation transition Time Setting",
ak4458_ats_enum),
SOC_ENUM("AK4458 BICK fs Setting", ak4458_dif_enum),
};
/* ak4458 dapm widgets */
static const struct snd_soc_dapm_widget ak4458_dapm_widgets[] = {
SND_SOC_DAPM_DAC("AK4458 DAC1", NULL, AK4458_0A_CONTROL6, 2, 0),/*pw*/
SND_SOC_DAPM_AIF_IN("AK4458 SDTI", "Playback", 0, SND_SOC_NOPM, 0, 0),
SND_SOC_DAPM_OUTPUT("AK4458 AOUTA"),
SND_SOC_DAPM_DAC("AK4458 DAC2", NULL, AK4458_0A_CONTROL6, 3, 0),/*pw*/
SND_SOC_DAPM_OUTPUT("AK4458 AOUTB"),
SND_SOC_DAPM_DAC("AK4458 DAC3", NULL, AK4458_0B_CONTROL7, 2, 0),/*pw*/
SND_SOC_DAPM_OUTPUT("AK4458 AOUTC"),
SND_SOC_DAPM_DAC("AK4458 DAC4", NULL, AK4458_0B_CONTROL7, 3, 0),/*pw*/
SND_SOC_DAPM_OUTPUT("AK4458 AOUTD"),
};
static const struct snd_soc_dapm_route ak4458_intercon[] = {
{"AK4458 DAC1", NULL, "AK4458 SDTI"},
{"AK4458 AOUTA", NULL, "AK4458 DAC1"},
{"AK4458 DAC2", NULL, "AK4458 SDTI"},
{"AK4458 AOUTB", NULL, "AK4458 DAC2"},
{"AK4458 DAC3", NULL, "AK4458 SDTI"},
{"AK4458 AOUTC", NULL, "AK4458 DAC3"},
{"AK4458 DAC4", NULL, "AK4458 SDTI"},
{"AK4458 AOUTD", NULL, "AK4458 DAC4"},
};
static int ak4458_rstn_control(struct snd_soc_component *component, int bit)
{
int ret;
if (bit)
ret = snd_soc_component_update_bits(component,
AK4458_00_CONTROL1,
AK4458_RSTN_MASK,
0x1);
else
ret = snd_soc_component_update_bits(component,
AK4458_00_CONTROL1,
AK4458_RSTN_MASK,
0x0);
return ret;
}
static int ak4458_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
{
struct snd_soc_component *component = dai->component;
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
int pcm_width = max(params_physical_width(params), ak4458->slot_width);
int nfs1;
u8 format;
nfs1 = params_rate(params);
ak4458->fs = nfs1;
/* Master Clock Frequency Auto Setting Mode Enable */
snd_soc_component_update_bits(component, AK4458_00_CONTROL1, 0x80, 0x80);
switch (pcm_width) {
case 16:
if (ak4458->fmt == SND_SOC_DAIFMT_I2S)
format = AK4458_DIF_24BIT_I2S;
else
format = AK4458_DIF_16BIT_LSB;
break;
case 32:
switch (ak4458->fmt) {
case SND_SOC_DAIFMT_I2S:
format = AK4458_DIF_32BIT_I2S;
break;
case SND_SOC_DAIFMT_LEFT_J:
format = AK4458_DIF_32BIT_MSB;
break;
case SND_SOC_DAIFMT_RIGHT_J:
format = AK4458_DIF_32BIT_LSB;
break;
case SND_SOC_DAIFMT_DSP_B:
format = AK4458_DIF_32BIT_MSB;
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
snd_soc_component_update_bits(component, AK4458_00_CONTROL1,
AK4458_DIF_MASK, format);
ak4458_rstn_control(component, 0);
ak4458_rstn_control(component, 1);
return 0;
}
static int ak4458_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
struct snd_soc_component *component = dai->component;
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
case SND_SOC_DAIFMT_CBS_CFS: /* Slave Mode */
break;
case SND_SOC_DAIFMT_CBM_CFM: /* Master Mode is not supported */
case SND_SOC_DAIFMT_CBS_CFM:
case SND_SOC_DAIFMT_CBM_CFS:
default:
dev_err(component->dev, "Master mode unsupported\n");
return -EINVAL;
}
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
case SND_SOC_DAIFMT_I2S:
case SND_SOC_DAIFMT_LEFT_J:
case SND_SOC_DAIFMT_RIGHT_J:
case SND_SOC_DAIFMT_DSP_B:
ak4458->fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
break;
default:
dev_err(component->dev, "Audio format 0x%02X unsupported\n",
fmt & SND_SOC_DAIFMT_FORMAT_MASK);
return -EINVAL;
}
ak4458_rstn_control(component, 0);
ak4458_rstn_control(component, 1);
return 0;
}
static const int att_speed[] = { 4080, 2040, 510, 255 };
static int ak4458_set_dai_mute(struct snd_soc_dai *dai, int mute)
{
struct snd_soc_component *component = dai->component;
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
int nfs, ndt, ret, reg;
int ats;
nfs = ak4458->fs;
reg = snd_soc_component_read32(component, AK4458_0B_CONTROL7);
ats = (reg & AK4458_ATS_MASK) >> AK4458_ATS_SHIFT;
ndt = att_speed[ats] / (nfs / 1000);
if (mute) {
ret = snd_soc_component_update_bits(component, AK4458_01_CONTROL2, 0x01, 1);
mdelay(ndt);
if (ak4458->mute_gpiod)
gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
} else {
if (ak4458->mute_gpiod)
gpiod_set_value_cansleep(ak4458->mute_gpiod, 0);
ret = snd_soc_component_update_bits(component, AK4458_01_CONTROL2, 0x01, 0);
mdelay(ndt);
}
return 0;
}
static int ak4458_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
unsigned int rx_mask, int slots, int slot_width)
{
struct snd_soc_component *component = dai->component;
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
int mode;
ak4458->slots = slots;
ak4458->slot_width = slot_width;
switch (slots * slot_width) {
case 128:
mode = AK4458_MODE_TDM128;
break;
case 256:
mode = AK4458_MODE_TDM256;
break;
case 512:
mode = AK4458_MODE_TDM512;
break;
default:
mode = AK4458_MODE_NORMAL;
break;
}
snd_soc_component_update_bits(component, AK4458_0A_CONTROL6,
AK4458_MODE_MASK,
mode);
return 0;
}
#define AK4458_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
SNDRV_PCM_FMTBIT_S24_LE |\
SNDRV_PCM_FMTBIT_S32_LE)
static const unsigned int ak4458_rates[] = {
8000, 11025, 16000, 22050,
32000, 44100, 48000, 88200,
96000, 176400, 192000, 352800,
384000, 705600, 768000, 1411200,
2822400,
};
static const struct snd_pcm_hw_constraint_list ak4458_rate_constraints = {
.count = ARRAY_SIZE(ak4458_rates),
.list = ak4458_rates,
};
static int ak4458_startup(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
int ret;
ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_RATE,
&ak4458_rate_constraints);
return ret;
}
static struct snd_soc_dai_ops ak4458_dai_ops = {
.startup = ak4458_startup,
.hw_params = ak4458_hw_params,
.set_fmt = ak4458_set_dai_fmt,
.digital_mute = ak4458_set_dai_mute,
.set_tdm_slot = ak4458_set_tdm_slot,
};
static struct snd_soc_dai_driver ak4458_dai = {
.name = "ak4458-aif",
.playback = {
.stream_name = "Playback",
.channels_min = 1,
.channels_max = 8,
.rates = SNDRV_PCM_RATE_KNOT,
.formats = AK4458_FORMATS,
},
.ops = &ak4458_dai_ops,
};
static void ak4458_power_off(struct ak4458_priv *ak4458)
{
if (ak4458->reset_gpiod) {
gpiod_set_value_cansleep(ak4458->reset_gpiod, 0);
usleep_range(1000, 2000);
}
}
static void ak4458_power_on(struct ak4458_priv *ak4458)
{
if (ak4458->reset_gpiod) {
gpiod_set_value_cansleep(ak4458->reset_gpiod, 1);
usleep_range(1000, 2000);
}
}
static void ak4458_init(struct snd_soc_component *component)
{
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
/* External Mute ON */
if (ak4458->mute_gpiod)
gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
ak4458_power_on(ak4458);
snd_soc_component_update_bits(component, AK4458_00_CONTROL1,
0x80, 0x80); /* ACKS bit = 1; 10000000 */
ak4458_rstn_control(component, 1);
}
static int ak4458_probe(struct snd_soc_component *component)
{
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
ak4458_init(component);
ak4458->fs = 48000;
return 0;
}
static void ak4458_remove(struct snd_soc_component *component)
{
struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
ak4458_power_off(ak4458);
}
#ifdef CONFIG_PM
static int __maybe_unused ak4458_runtime_suspend(struct device *dev)
{
struct ak4458_priv *ak4458 = dev_get_drvdata(dev);
regcache_cache_only(ak4458->regmap, true);
ak4458_power_off(ak4458);
if (ak4458->mute_gpiod)
gpiod_set_value_cansleep(ak4458->mute_gpiod, 0);
return 0;
}
static int __maybe_unused ak4458_runtime_resume(struct device *dev)
{
struct ak4458_priv *ak4458 = dev_get_drvdata(dev);
if (ak4458->mute_gpiod)
gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
ak4458_power_off(ak4458);
ak4458_power_on(ak4458);
regcache_cache_only(ak4458->regmap, false);
regcache_mark_dirty(ak4458->regmap);
return regcache_sync(ak4458->regmap);
}
#endif /* CONFIG_PM */
struct snd_soc_component_driver soc_codec_dev_ak4458 = {
.probe = ak4458_probe,
.remove = ak4458_remove,
.controls = ak4458_snd_controls,
.num_controls = ARRAY_SIZE(ak4458_snd_controls),
.dapm_widgets = ak4458_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ak4458_dapm_widgets),
.dapm_routes = ak4458_intercon,
.num_dapm_routes = ARRAY_SIZE(ak4458_intercon),
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static const struct regmap_config ak4458_regmap = {
.reg_bits = 8,
.val_bits = 8,
.max_register = AK4458_14_R4CHATT,
.reg_defaults = ak4458_reg_defaults,
.num_reg_defaults = ARRAY_SIZE(ak4458_reg_defaults),
.cache_type = REGCACHE_RBTREE,
};
static const struct dev_pm_ops ak4458_pm = {
SET_RUNTIME_PM_OPS(ak4458_runtime_suspend, ak4458_runtime_resume, NULL)
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
};
static int ak4458_i2c_probe(struct i2c_client *i2c)
{
struct ak4458_priv *ak4458;
int ret;
ak4458 = devm_kzalloc(&i2c->dev, sizeof(*ak4458), GFP_KERNEL);
if (!ak4458)
return -ENOMEM;
ak4458->regmap = devm_regmap_init_i2c(i2c, &ak4458_regmap);
if (IS_ERR(ak4458->regmap))
return PTR_ERR(ak4458->regmap);
i2c_set_clientdata(i2c, ak4458);
ak4458->dev = &i2c->dev;
ak4458->reset_gpiod = devm_gpiod_get_optional(ak4458->dev, "reset",
GPIOD_OUT_LOW);
if (IS_ERR(ak4458->reset_gpiod))
return PTR_ERR(ak4458->reset_gpiod);
ak4458->mute_gpiod = devm_gpiod_get_optional(ak4458->dev, "mute",
GPIOD_OUT_LOW);
if (IS_ERR(ak4458->mute_gpiod))
return PTR_ERR(ak4458->mute_gpiod);
ret = devm_snd_soc_register_component(ak4458->dev, &soc_codec_dev_ak4458,
&ak4458_dai, 1);
if (ret < 0) {
dev_err(ak4458->dev, "Failed to register CODEC: %d\n", ret);
return ret;
}
pm_runtime_enable(&i2c->dev);
return 0;
}
static int ak4458_i2c_remove(struct i2c_client *i2c)
{
pm_runtime_disable(&i2c->dev);
return 0;
}
static const struct of_device_id ak4458_of_match[] = {
{ .compatible = "asahi-kasei,ak4458", },
{ },
};
static struct i2c_driver ak4458_i2c_driver = {
.driver = {
.name = "ak4458",
.pm = &ak4458_pm,
.of_match_table = ak4458_of_match,
},
.probe_new = ak4458_i2c_probe,
.remove = ak4458_i2c_remove,
};
module_i2c_driver(ak4458_i2c_driver);
MODULE_AUTHOR("Junichi Wakasugi <wakasugi.jb@om.asahi-kasei.co.jp>");
MODULE_AUTHOR("Mihai Serban <mihai.serban@nxp.com>");
MODULE_DESCRIPTION("ASoC AK4458 DAC driver");
MODULE_LICENSE("GPL v2");

86
sound/soc/codecs/ak4458.h Normal file
View File

@ -0,0 +1,86 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Audio driver for AK4458
*
* Copyright (C) 2016 Asahi Kasei Microdevices Corporation
* Copyright 2018 NXP
*/
#ifndef _AK4458_H
#define _AK4458_H
#include <linux/regmap.h>
/* Settings */
#define AK4458_00_CONTROL1 0x00
#define AK4458_01_CONTROL2 0x01
#define AK4458_02_CONTROL3 0x02
#define AK4458_03_LCHATT 0x03
#define AK4458_04_RCHATT 0x04
#define AK4458_05_CONTROL4 0x05
#define AK4458_06_DSD1 0x06
#define AK4458_07_CONTROL5 0x07
#define AK4458_08_SOUND_CONTROL 0x08
#define AK4458_09_DSD2 0x09
#define AK4458_0A_CONTROL6 0x0A
#define AK4458_0B_CONTROL7 0x0B
#define AK4458_0C_CONTROL8 0x0C
#define AK4458_0D_CONTROL9 0x0D
#define AK4458_0E_CONTROL10 0x0E
#define AK4458_0F_L2CHATT 0x0F
#define AK4458_10_R2CHATT 0x10
#define AK4458_11_L3CHATT 0x11
#define AK4458_12_R3CHATT 0x12
#define AK4458_13_L4CHATT 0x13
#define AK4458_14_R4CHATT 0x14
/* Bitfield Definitions */
/* AK4458_00_CONTROL1 (0x00) Fields
* Addr Register Name D7 D6 D5 D4 D3 D2 D1 D0
* 00H Control 1 ACKS 0 0 0 DIF2 DIF1 DIF0 RSTN
*/
/* Digital Filter (SD, SLOW, SSLOW) */
#define AK4458_SD_MASK GENMASK(5, 5)
#define AK4458_SLOW_MASK GENMASK(0, 0)
#define AK4458_SSLOW_MASK GENMASK(0, 0)
/* DIF2 1 0
* x 1 0 MSB justified Figure 3 (default)
* x 1 1 I2S Compliment Figure 4
*/
#define AK4458_DIF_SHIFT 1
#define AK4458_DIF_MASK GENMASK(3, 1)
#define AK4458_DIF_16BIT_LSB (0 << 1)
#define AK4458_DIF_24BIT_I2S (3 << 1)
#define AK4458_DIF_32BIT_LSB (5 << 1)
#define AK4458_DIF_32BIT_MSB (6 << 1)
#define AK4458_DIF_32BIT_I2S (7 << 1)
/* AK4458_00_CONTROL1 (0x00) D0 bit */
#define AK4458_RSTN_MASK GENMASK(0, 0)
#define AK4458_RSTN (0x1 << 0)
/* AK4458_0A_CONTROL6 Mode bits */
#define AK4458_MODE_SHIFT 6
#define AK4458_MODE_MASK GENMASK(7, 6)
#define AK4458_MODE_NORMAL (0 << AK4458_MODE_SHIFT)
#define AK4458_MODE_TDM128 (1 << AK4458_MODE_SHIFT)
#define AK4458_MODE_TDM256 (2 << AK4458_MODE_SHIFT)
#define AK4458_MODE_TDM512 (3 << AK4458_MODE_SHIFT)
/* DAC Digital attenuator transition time setting
* Table 19
* Mode ATS1 ATS2 ATT speed
* 0 0 0 4080/fs
* 1 0 1 2040/fs
* 2 1 0 510/fs
* 3 1 1 255/fs
* */
#define AK4458_ATS_SHIFT 6
#define AK4458_ATS_MASK GENMASK(7, 6)
#endif /* _AK4458_H */

78
sound/soc/codecs/ak4535.c
View File

@ -251,8 +251,8 @@ static const struct snd_soc_dapm_route ak4535_audio_map[] = {
static int ak4535_set_dai_sysclk(struct snd_soc_dai *codec_dai,
int clk_id, unsigned int freq, int dir)
{
struct snd_soc_codec *codec = codec_dai->codec;
struct ak4535_priv *ak4535 = snd_soc_codec_get_drvdata(codec);
struct snd_soc_component *component = codec_dai->component;
struct ak4535_priv *ak4535 = snd_soc_component_get_drvdata(component);
ak4535->sysclk = freq;
return 0;
@ -262,9 +262,9 @@ static int ak4535_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 ak4535_priv *ak4535 = snd_soc_codec_get_drvdata(codec);
u8 mode2 = snd_soc_read(codec, AK4535_MODE2) & ~(0x3 << 5);
struct snd_soc_component *component = dai->component;
struct ak4535_priv *ak4535 = snd_soc_component_get_drvdata(component);
u8 mode2 = snd_soc_component_read32(component, AK4535_MODE2) & ~(0x3 << 5);
int rate = params_rate(params), fs = 256;
if (rate)
@ -283,14 +283,14 @@ static int ak4535_hw_params(struct snd_pcm_substream *substream,
}
/* set rate */
snd_soc_write(codec, AK4535_MODE2, mode2);
snd_soc_component_write(component, AK4535_MODE2, mode2);
return 0;
}
static int ak4535_set_dai_fmt(struct snd_soc_dai *codec_dai,
unsigned int fmt)
{
struct snd_soc_codec *codec = codec_dai->codec;
struct snd_soc_component *component = codec_dai->component;
u8 mode1 = 0;
/* interface format */
@ -308,37 +308,37 @@ static int ak4535_set_dai_fmt(struct snd_soc_dai *codec_dai,
/* use 32 fs for BCLK to save power */
mode1 |= 0x4;
snd_soc_write(codec, AK4535_MODE1, mode1);
snd_soc_component_write(component, AK4535_MODE1, mode1);
return 0;
}
static int ak4535_mute(struct snd_soc_dai *dai, int mute)
{
struct snd_soc_codec *codec = dai->codec;
u16 mute_reg = snd_soc_read(codec, AK4535_DAC);
struct snd_soc_component *component = dai->component;
u16 mute_reg = snd_soc_component_read32(component, AK4535_DAC);
if (!mute)
snd_soc_write(codec, AK4535_DAC, mute_reg & ~0x20);
snd_soc_component_write(component, AK4535_DAC, mute_reg & ~0x20);
else
snd_soc_write(codec, AK4535_DAC, mute_reg | 0x20);
snd_soc_component_write(component, AK4535_DAC, mute_reg | 0x20);
return 0;
}
static int ak4535_set_bias_level(struct snd_soc_codec *codec,
static int ak4535_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level)
{
switch (level) {
case SND_SOC_BIAS_ON:
snd_soc_update_bits(codec, AK4535_DAC, 0x20, 0);
snd_soc_component_update_bits(component, AK4535_DAC, 0x20, 0);
break;
case SND_SOC_BIAS_PREPARE:
snd_soc_update_bits(codec, AK4535_DAC, 0x20, 0x20);
snd_soc_component_update_bits(component, AK4535_DAC, 0x20, 0x20);
break;
case SND_SOC_BIAS_STANDBY:
snd_soc_update_bits(codec, AK4535_PM1, 0x80, 0x80);
snd_soc_update_bits(codec, AK4535_PM2, 0x80, 0);
snd_soc_component_update_bits(component, AK4535_PM1, 0x80, 0x80);
snd_soc_component_update_bits(component, AK4535_PM2, 0x80, 0);
break;
case SND_SOC_BIAS_OFF:
snd_soc_update_bits(codec, AK4535_PM1, 0x80, 0);
snd_soc_component_update_bits(component, AK4535_PM1, 0x80, 0);
break;
}
return 0;
@ -372,9 +372,9 @@ static struct snd_soc_dai_driver ak4535_dai = {
.ops = &ak4535_dai_ops,
};
static int ak4535_resume(struct snd_soc_codec *codec)
static int ak4535_resume(struct snd_soc_component *component)
{
snd_soc_cache_sync(codec);
snd_soc_component_cache_sync(component);
return 0;
}
@ -390,19 +390,20 @@ static const struct regmap_config ak4535_regmap = {
.num_reg_defaults = ARRAY_SIZE(ak4535_reg_defaults),
};
static const struct snd_soc_codec_driver soc_codec_dev_ak4535 = {
.resume = ak4535_resume,
.set_bias_level = ak4535_set_bias_level,
.suspend_bias_off = true,
.component_driver = {
.controls = ak4535_snd_controls,
.num_controls = ARRAY_SIZE(ak4535_snd_controls),
.dapm_widgets = ak4535_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ak4535_dapm_widgets),
.dapm_routes = ak4535_audio_map,
.num_dapm_routes = ARRAY_SIZE(ak4535_audio_map),
},
static const struct snd_soc_component_driver soc_component_dev_ak4535 = {
.resume = ak4535_resume,
.set_bias_level = ak4535_set_bias_level,
.controls = ak4535_snd_controls,
.num_controls = ARRAY_SIZE(ak4535_snd_controls),
.dapm_widgets = ak4535_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(ak4535_dapm_widgets),
.dapm_routes = ak4535_audio_map,
.num_dapm_routes = ARRAY_SIZE(ak4535_audio_map),
.suspend_bias_off = 1,
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static int ak4535_i2c_probe(struct i2c_client *i2c,
@ -425,18 +426,12 @@ static int ak4535_i2c_probe(struct i2c_client *i2c,
i2c_set_clientdata(i2c, ak4535);
ret = snd_soc_register_codec(&i2c->dev,
&soc_codec_dev_ak4535, &ak4535_dai, 1);
ret = devm_snd_soc_register_component(&i2c->dev,
&soc_component_dev_ak4535, &ak4535_dai, 1);
return ret;
}
static int ak4535_i2c_remove(struct i2c_client *client)
{
snd_soc_unregister_codec(&client->dev);
return 0;
}
static const struct i2c_device_id ak4535_i2c_id[] = {
{ "ak4535", 0 },
{ }
@ -448,7 +443,6 @@ static struct i2c_driver ak4535_i2c_driver = {
.name = "ak4535",
},
.probe = ak4535_i2c_probe,
.remove = ak4535_i2c_remove,
.id_table = ak4535_i2c_id,
};