soc/codecs/ad1836.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002  /*
0003  * Audio Codec driver supporting:
0004  *  AD1835A, AD1836, AD1837A, AD1838A, AD1839A
0005  *
0006  * Copyright 2009-2011 Analog Devices Inc.
0007  */
0008
0009 #include <linux/init.h>
0010 #include <linux/slab.h>
0011 #include <linux/module.h>
0012 #include <linux/kernel.h>
0013 #include <linux/device.h>
0014 #include <sound/core.h>
0015 #include <sound/pcm.h>
0016 #include <sound/pcm_params.h>
0017 #include <sound/initval.h>
0018 #include <sound/soc.h>
0019 #include <sound/tlv.h>
0020 #include <linux/spi/spi.h>
0021 #include <linux/regmap.h>
0022
0023 #include "ad1836.h"
0024
0025 enum ad1836_type {
0026     AD1835,
0027     AD1836,
0028     AD1838,
0029 };
0030
0031 /* codec private data */
0032 struct ad1836_priv {
0033     enum ad1836_type type;
0034     struct regmap *regmap;
0035 };
0036
0037 /*
0038  * AD1836 volume/mute/de-emphasis etc. controls
0039  */
0040 static const char *ad1836_deemp[] = {"None", "44.1kHz", "32kHz", "48kHz"};
0041
0042 static SOC_ENUM_SINGLE_DECL(ad1836_deemp_enum,
0043                 AD1836_DAC_CTRL1, 8, ad1836_deemp);
0044
0045 #define AD1836_DAC_VOLUME(x) \
0046     SOC_DOUBLE_R("DAC" #x " Playback Volume", AD1836_DAC_L_VOL(x), \
0047             AD1836_DAC_R_VOL(x), 0, 0x3FF, 0)
0048
0049 #define AD1836_DAC_SWITCH(x) \
0050     SOC_DOUBLE("DAC" #x " Playback Switch", AD1836_DAC_CTRL2, \
0051             AD1836_MUTE_LEFT(x), AD1836_MUTE_RIGHT(x), 1, 1)
0052
0053 #define AD1836_ADC_SWITCH(x) \
0054     SOC_DOUBLE("ADC" #x " Capture Switch", AD1836_ADC_CTRL2, \
0055         AD1836_MUTE_LEFT(x), AD1836_MUTE_RIGHT(x), 1, 1)
0056
0057 static const struct snd_kcontrol_new ad183x_dac_controls[] = {
0058     AD1836_DAC_VOLUME(1),
0059     AD1836_DAC_SWITCH(1),
0060     AD1836_DAC_VOLUME(2),
0061     AD1836_DAC_SWITCH(2),
0062     AD1836_DAC_VOLUME(3),
0063     AD1836_DAC_SWITCH(3),
0064     AD1836_DAC_VOLUME(4),
0065     AD1836_DAC_SWITCH(4),
0066 };
0067
0068 static const struct snd_soc_dapm_widget ad183x_dac_dapm_widgets[] = {
0069     SND_SOC_DAPM_OUTPUT("DAC1OUT"),
0070     SND_SOC_DAPM_OUTPUT("DAC2OUT"),
0071     SND_SOC_DAPM_OUTPUT("DAC3OUT"),
0072     SND_SOC_DAPM_OUTPUT("DAC4OUT"),
0073 };
0074
0075 static const struct snd_soc_dapm_route ad183x_dac_routes[] = {
0076     { "DAC1OUT", NULL, "DAC" },
0077     { "DAC2OUT", NULL, "DAC" },
0078     { "DAC3OUT", NULL, "DAC" },
0079     { "DAC4OUT", NULL, "DAC" },
0080 };
0081
0082 static const struct snd_kcontrol_new ad183x_adc_controls[] = {
0083     AD1836_ADC_SWITCH(1),
0084     AD1836_ADC_SWITCH(2),
0085     AD1836_ADC_SWITCH(3),
0086 };
0087
0088 static const struct snd_soc_dapm_widget ad183x_adc_dapm_widgets[] = {
0089     SND_SOC_DAPM_INPUT("ADC1IN"),
0090     SND_SOC_DAPM_INPUT("ADC2IN"),
0091 };
0092
0093 static const struct snd_soc_dapm_route ad183x_adc_routes[] = {
0094     { "ADC", NULL, "ADC1IN" },
0095     { "ADC", NULL, "ADC2IN" },
0096 };
0097
0098 static const struct snd_kcontrol_new ad183x_controls[] = {
0099     /* ADC high-pass filter */
0100     SOC_SINGLE("ADC High Pass Filter Switch", AD1836_ADC_CTRL1,
0101             AD1836_ADC_HIGHPASS_FILTER, 1, 0),
0102
0103     /* DAC de-emphasis */
0104     SOC_ENUM("Playback Deemphasis", ad1836_deemp_enum),
0105 };
0106
0107 static const struct snd_soc_dapm_widget ad183x_dapm_widgets[] = {
0108     SND_SOC_DAPM_DAC("DAC", "Playback", AD1836_DAC_CTRL1,
0109                 AD1836_DAC_POWERDOWN, 1),
0110     SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
0111     SND_SOC_DAPM_SUPPLY("ADC_PWR", AD1836_ADC_CTRL1,
0112                 AD1836_ADC_POWERDOWN, 1, NULL, 0),
0113 };
0114
0115 static const struct snd_soc_dapm_route ad183x_dapm_routes[] = {
0116     { "DAC", NULL, "ADC_PWR" },
0117     { "ADC", NULL, "ADC_PWR" },
0118 };
0119
0120 static const DECLARE_TLV_DB_SCALE(ad1836_in_tlv, 0, 300, 0);
0121
0122 static const struct snd_kcontrol_new ad1836_controls[] = {
0123     SOC_DOUBLE_TLV("ADC2 Capture Volume", AD1836_ADC_CTRL1, 3, 0, 4, 0,
0124         ad1836_in_tlv),
0125 };
0126
0127 /*
0128  * DAI ops entries
0129  */
0130
0131 static int ad1836_set_dai_fmt(struct snd_soc_dai *codec_dai,
0132         unsigned int fmt)
0133 {
0134     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
0135     /* at present, we support adc aux mode to interface with
0136      * blackfin sport tdm mode
0137      */
0138     case SND_SOC_DAIFMT_DSP_A:
0139         break;
0140     default:
0141         return -EINVAL;
0142     }
0143
0144     switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
0145     case SND_SOC_DAIFMT_IB_IF:
0146         break;
0147     default:
0148         return -EINVAL;
0149     }
0150
0151     switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
0152     /* ALCLK,ABCLK are both output, AD1836 can only be provider */
0153     case SND_SOC_DAIFMT_CBP_CFP:
0154         break;
0155     default:
0156         return -EINVAL;
0157     }
0158
0159     return 0;
0160 }
0161
0162 static int ad1836_hw_params(struct snd_pcm_substream *substream,
0163         struct snd_pcm_hw_params *params,
0164         struct snd_soc_dai *dai)
0165 {
0166     struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(dai->component);
0167     int word_len = 0;
0168
0169     /* bit size */
0170     switch (params_width(params)) {
0171     case 16:
0172         word_len = AD1836_WORD_LEN_16;
0173         break;
0174     case 20:
0175         word_len = AD1836_WORD_LEN_20;
0176         break;
0177     case 24:
0178     case 32:
0179         word_len = AD1836_WORD_LEN_24;
0180         break;
0181     default:
0182         return -EINVAL;
0183     }
0184
0185     regmap_update_bits(ad1836->regmap, AD1836_DAC_CTRL1,
0186         AD1836_DAC_WORD_LEN_MASK,
0187         word_len << AD1836_DAC_WORD_LEN_OFFSET);
0188
0189     regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
0190         AD1836_ADC_WORD_LEN_MASK,
0191         word_len << AD1836_ADC_WORD_OFFSET);
0192
0193     return 0;
0194 }
0195
0196 static const struct snd_soc_dai_ops ad1836_dai_ops = {
0197     .hw_params = ad1836_hw_params,
0198     .set_fmt = ad1836_set_dai_fmt,
0199 };
0200
0201 #define AD183X_DAI(_name, num_dacs, num_adcs) \
0202 { \
0203     .name = _name "-hifi", \
0204     .playback = { \
0205         .stream_name = "Playback", \
0206         .channels_min = 2, \
0207         .channels_max = (num_dacs) * 2, \
0208         .rates = SNDRV_PCM_RATE_48000,  \
0209         .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | \
0210             SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, \
0211     }, \
0212     .capture = { \
0213         .stream_name = "Capture", \
0214         .channels_min = 2, \
0215         .channels_max = (num_adcs) * 2, \
0216         .rates = SNDRV_PCM_RATE_48000, \
0217         .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | \
0218             SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, \
0219     }, \
0220     .ops = &ad1836_dai_ops, \
0221 }
0222
0223 static struct snd_soc_dai_driver ad183x_dais[] = {
0224     [AD1835] = AD183X_DAI("ad1835", 4, 1),
0225     [AD1836] = AD183X_DAI("ad1836", 3, 2),
0226     [AD1838] = AD183X_DAI("ad1838", 3, 1),
0227 };
0228
0229 #ifdef CONFIG_PM
0230 static int ad1836_suspend(struct snd_soc_component *component)
0231 {
0232     struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component);
0233     /* reset clock control mode */
0234     return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
0235         AD1836_ADC_SERFMT_MASK, 0);
0236 }
0237
0238 static int ad1836_resume(struct snd_soc_component *component)
0239 {
0240     struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component);
0241     /* restore clock control mode */
0242     return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
0243         AD1836_ADC_SERFMT_MASK, AD1836_ADC_AUX);
0244 }
0245 #else
0246 #define ad1836_suspend NULL
0247 #define ad1836_resume  NULL
0248 #endif
0249
0250 static int ad1836_probe(struct snd_soc_component *component)
0251 {
0252     struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component);
0253     struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
0254     int num_dacs, num_adcs;
0255     int ret = 0;
0256     int i;
0257
0258     num_dacs = ad183x_dais[ad1836->type].playback.channels_max / 2;
0259     num_adcs = ad183x_dais[ad1836->type].capture.channels_max / 2;
0260
0261     /* default setting for ad1836 */
0262     /* de-emphasis: 48kHz, power-on dac */
0263     regmap_write(ad1836->regmap, AD1836_DAC_CTRL1, 0x300);
0264     /* unmute dac channels */
0265     regmap_write(ad1836->regmap, AD1836_DAC_CTRL2, 0x0);
0266     /* high-pass filter enable, power-on adc */
0267     regmap_write(ad1836->regmap, AD1836_ADC_CTRL1, 0x100);
0268     /* unmute adc channles, adc aux mode */
0269     regmap_write(ad1836->regmap, AD1836_ADC_CTRL2, 0x180);
0270     /* volume */
0271     for (i = 1; i <= num_dacs; ++i) {
0272         regmap_write(ad1836->regmap, AD1836_DAC_L_VOL(i), 0x3FF);
0273         regmap_write(ad1836->regmap, AD1836_DAC_R_VOL(i), 0x3FF);
0274     }
0275
0276     if (ad1836->type == AD1836) {
0277         /* left/right diff:PGA/MUX */
0278         regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x3A);
0279         ret = snd_soc_add_component_controls(component, ad1836_controls,
0280                 ARRAY_SIZE(ad1836_controls));
0281         if (ret)
0282             return ret;
0283     } else {
0284         regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x00);
0285     }
0286
0287     ret = snd_soc_add_component_controls(component, ad183x_dac_controls, num_dacs * 2);
0288     if (ret)
0289         return ret;
0290
0291     ret = snd_soc_add_component_controls(component, ad183x_adc_controls, num_adcs);
0292     if (ret)
0293         return ret;
0294
0295     ret = snd_soc_dapm_new_controls(dapm, ad183x_dac_dapm_widgets, num_dacs);
0296     if (ret)
0297         return ret;
0298
0299     ret = snd_soc_dapm_new_controls(dapm, ad183x_adc_dapm_widgets, num_adcs);
0300     if (ret)
0301         return ret;
0302
0303     ret = snd_soc_dapm_add_routes(dapm, ad183x_dac_routes, num_dacs);
0304     if (ret)
0305         return ret;
0306
0307     ret = snd_soc_dapm_add_routes(dapm, ad183x_adc_routes, num_adcs);
0308
0309     return ret;
0310 }
0311
0312 /* power down chip */
0313 static void ad1836_remove(struct snd_soc_component *component)
0314 {
0315     struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component);
0316     /* reset clock control mode */
0317     regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
0318         AD1836_ADC_SERFMT_MASK, 0);
0319 }
0320
0321 static const struct snd_soc_component_driver soc_component_dev_ad1836 = {
0322     .probe          = ad1836_probe,
0323     .remove         = ad1836_remove,
0324     .suspend        = ad1836_suspend,
0325     .resume         = ad1836_resume,
0326     .controls       = ad183x_controls,
0327     .num_controls       = ARRAY_SIZE(ad183x_controls),
0328     .dapm_widgets       = ad183x_dapm_widgets,
0329     .num_dapm_widgets   = ARRAY_SIZE(ad183x_dapm_widgets),
0330     .dapm_routes        = ad183x_dapm_routes,
0331     .num_dapm_routes    = ARRAY_SIZE(ad183x_dapm_routes),
0332     .idle_bias_on       = 1,
0333     .use_pmdown_time    = 1,
0334     .endianness     = 1,
0335 };
0336
0337 static const struct reg_default ad1836_reg_defaults[] = {
0338     { AD1836_DAC_CTRL1, 0x0000 },
0339     { AD1836_DAC_CTRL2, 0x0000 },
0340     { AD1836_DAC_L_VOL(0), 0x0000 },
0341     { AD1836_DAC_R_VOL(0), 0x0000 },
0342     { AD1836_DAC_L_VOL(1), 0x0000 },
0343     { AD1836_DAC_R_VOL(1), 0x0000 },
0344     { AD1836_DAC_L_VOL(2), 0x0000 },
0345     { AD1836_DAC_R_VOL(2), 0x0000 },
0346     { AD1836_DAC_L_VOL(3), 0x0000 },
0347     { AD1836_DAC_R_VOL(3), 0x0000 },
0348     { AD1836_ADC_CTRL1, 0x0000 },
0349     { AD1836_ADC_CTRL2, 0x0000 },
0350     { AD1836_ADC_CTRL3, 0x0000 },
0351 };
0352
0353 static const struct regmap_config ad1836_regmap_config = {
0354     .val_bits = 12,
0355     .reg_bits = 4,
0356     .read_flag_mask = 0x08,
0357
0358     .max_register = AD1836_ADC_CTRL3,
0359     .reg_defaults = ad1836_reg_defaults,
0360     .num_reg_defaults = ARRAY_SIZE(ad1836_reg_defaults),
0361     .cache_type = REGCACHE_RBTREE,
0362 };
0363
0364 static int ad1836_spi_probe(struct spi_device *spi)
0365 {
0366     struct ad1836_priv *ad1836;
0367     int ret;
0368
0369     ad1836 = devm_kzalloc(&spi->dev, sizeof(struct ad1836_priv),
0370                   GFP_KERNEL);
0371     if (ad1836 == NULL)
0372         return -ENOMEM;
0373
0374     ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config);
0375     if (IS_ERR(ad1836->regmap))
0376         return PTR_ERR(ad1836->regmap);
0377
0378     ad1836->type = spi_get_device_id(spi)->driver_data;
0379
0380     spi_set_drvdata(spi, ad1836);
0381
0382     ret = devm_snd_soc_register_component(&spi->dev,
0383             &soc_component_dev_ad1836, &ad183x_dais[ad1836->type], 1);
0384     return ret;
0385 }
0386
0387 static const struct spi_device_id ad1836_ids[] = {
0388     { "ad1835", AD1835 },
0389     { "ad1836", AD1836 },
0390     { "ad1837", AD1835 },
0391     { "ad1838", AD1838 },
0392     { "ad1839", AD1838 },
0393     { },
0394 };
0395 MODULE_DEVICE_TABLE(spi, ad1836_ids);
0396
0397 static struct spi_driver ad1836_spi_driver = {
0398     .driver = {
0399         .name   = "ad1836",
0400     },
0401     .probe      = ad1836_spi_probe,
0402     .id_table   = ad1836_ids,
0403 };
0404
0405 module_spi_driver(ad1836_spi_driver);
0406
0407 MODULE_DESCRIPTION("ASoC ad1836 driver");
0408 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
0409 MODULE_LICENSE("GPL");