1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Audio Codec driver supporting: 4 * AD1835A, AD1836, AD1837A, AD1838A, AD1839A 5 * 6 * Copyright 2009-2011 Analog Devices Inc. 7 */ 8 9 #include <linux/init.h> 10 #include <linux/slab.h> 11 #include <linux/module.h> 12 #include <linux/kernel.h> 13 #include <linux/device.h> 14 #include <sound/core.h> 15 #include <sound/pcm.h> 16 #include <sound/pcm_params.h> 17 #include <sound/initval.h> 18 #include <sound/soc.h> 19 #include <sound/tlv.h> 20 #include <linux/spi/spi.h> 21 #include <linux/regmap.h> 22 23 #include "ad1836.h" 24 25 enum ad1836_type { 26 AD1835, 27 AD1836, 28 AD1838, 29 }; 30 31 /* codec private data */ 32 struct ad1836_priv { 33 enum ad1836_type type; 34 struct regmap *regmap; 35 }; 36 37 /* 38 * AD1836 volume/mute/de-emphasis etc. controls 39 */ 40 static const char *ad1836_deemp[] = {"None", "44.1kHz", "32kHz", "48kHz"}; 41 42 static SOC_ENUM_SINGLE_DECL(ad1836_deemp_enum, 43 AD1836_DAC_CTRL1, 8, ad1836_deemp); 44 45 #define AD1836_DAC_VOLUME(x) \ 46 SOC_DOUBLE_R("DAC" #x " Playback Volume", AD1836_DAC_L_VOL(x), \ 47 AD1836_DAC_R_VOL(x), 0, 0x3FF, 0) 48 49 #define AD1836_DAC_SWITCH(x) \ 50 SOC_DOUBLE("DAC" #x " Playback Switch", AD1836_DAC_CTRL2, \ 51 AD1836_MUTE_LEFT(x), AD1836_MUTE_RIGHT(x), 1, 1) 52 53 #define AD1836_ADC_SWITCH(x) \ 54 SOC_DOUBLE("ADC" #x " Capture Switch", AD1836_ADC_CTRL2, \ 55 AD1836_MUTE_LEFT(x), AD1836_MUTE_RIGHT(x), 1, 1) 56 57 static const struct snd_kcontrol_new ad183x_dac_controls[] = { 58 AD1836_DAC_VOLUME(1), 59 AD1836_DAC_SWITCH(1), 60 AD1836_DAC_VOLUME(2), 61 AD1836_DAC_SWITCH(2), 62 AD1836_DAC_VOLUME(3), 63 AD1836_DAC_SWITCH(3), 64 AD1836_DAC_VOLUME(4), 65 AD1836_DAC_SWITCH(4), 66 }; 67 68 static const struct snd_soc_dapm_widget ad183x_dac_dapm_widgets[] = { 69 SND_SOC_DAPM_OUTPUT("DAC1OUT"), 70 SND_SOC_DAPM_OUTPUT("DAC2OUT"), 71 SND_SOC_DAPM_OUTPUT("DAC3OUT"), 72 SND_SOC_DAPM_OUTPUT("DAC4OUT"), 73 }; 74 75 static const struct snd_soc_dapm_route ad183x_dac_routes[] = { 76 { "DAC1OUT", NULL, "DAC" }, 77 { "DAC2OUT", NULL, "DAC" }, 78 { "DAC3OUT", NULL, "DAC" }, 79 { "DAC4OUT", NULL, "DAC" }, 80 }; 81 82 static const struct snd_kcontrol_new ad183x_adc_controls[] = { 83 AD1836_ADC_SWITCH(1), 84 AD1836_ADC_SWITCH(2), 85 AD1836_ADC_SWITCH(3), 86 }; 87 88 static const struct snd_soc_dapm_widget ad183x_adc_dapm_widgets[] = { 89 SND_SOC_DAPM_INPUT("ADC1IN"), 90 SND_SOC_DAPM_INPUT("ADC2IN"), 91 }; 92 93 static const struct snd_soc_dapm_route ad183x_adc_routes[] = { 94 { "ADC", NULL, "ADC1IN" }, 95 { "ADC", NULL, "ADC2IN" }, 96 }; 97 98 static const struct snd_kcontrol_new ad183x_controls[] = { 99 /* ADC high-pass filter */ 100 SOC_SINGLE("ADC High Pass Filter Switch", AD1836_ADC_CTRL1, 101 AD1836_ADC_HIGHPASS_FILTER, 1, 0), 102 103 /* DAC de-emphasis */ 104 SOC_ENUM("Playback Deemphasis", ad1836_deemp_enum), 105 }; 106 107 static const struct snd_soc_dapm_widget ad183x_dapm_widgets[] = { 108 SND_SOC_DAPM_DAC("DAC", "Playback", AD1836_DAC_CTRL1, 109 AD1836_DAC_POWERDOWN, 1), 110 SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0), 111 SND_SOC_DAPM_SUPPLY("ADC_PWR", AD1836_ADC_CTRL1, 112 AD1836_ADC_POWERDOWN, 1, NULL, 0), 113 }; 114 115 static const struct snd_soc_dapm_route ad183x_dapm_routes[] = { 116 { "DAC", NULL, "ADC_PWR" }, 117 { "ADC", NULL, "ADC_PWR" }, 118 }; 119 120 static const DECLARE_TLV_DB_SCALE(ad1836_in_tlv, 0, 300, 0); 121 122 static const struct snd_kcontrol_new ad1836_controls[] = { 123 SOC_DOUBLE_TLV("ADC2 Capture Volume", AD1836_ADC_CTRL1, 3, 0, 4, 0, 124 ad1836_in_tlv), 125 }; 126 127 /* 128 * DAI ops entries 129 */ 130 131 static int ad1836_set_dai_fmt(struct snd_soc_dai *codec_dai, 132 unsigned int fmt) 133 { 134 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 135 /* at present, we support adc aux mode to interface with 136 * blackfin sport tdm mode 137 */ 138 case SND_SOC_DAIFMT_DSP_A: 139 break; 140 default: 141 return -EINVAL; 142 } 143 144 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 145 case SND_SOC_DAIFMT_IB_IF: 146 break; 147 default: 148 return -EINVAL; 149 } 150 151 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 152 /* ALCLK,ABCLK are both output, AD1836 can only be provider */ 153 case SND_SOC_DAIFMT_CBP_CFP: 154 break; 155 default: 156 return -EINVAL; 157 } 158 159 return 0; 160 } 161 162 static int ad1836_hw_params(struct snd_pcm_substream *substream, 163 struct snd_pcm_hw_params *params, 164 struct snd_soc_dai *dai) 165 { 166 struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(dai->component); 167 int word_len = 0; 168 169 /* bit size */ 170 switch (params_width(params)) { 171 case 16: 172 word_len = AD1836_WORD_LEN_16; 173 break; 174 case 20: 175 word_len = AD1836_WORD_LEN_20; 176 break; 177 case 24: 178 case 32: 179 word_len = AD1836_WORD_LEN_24; 180 break; 181 default: 182 return -EINVAL; 183 } 184 185 regmap_update_bits(ad1836->regmap, AD1836_DAC_CTRL1, 186 AD1836_DAC_WORD_LEN_MASK, 187 word_len << AD1836_DAC_WORD_LEN_OFFSET); 188 189 regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, 190 AD1836_ADC_WORD_LEN_MASK, 191 word_len << AD1836_ADC_WORD_OFFSET); 192 193 return 0; 194 } 195 196 static const u64 ad1836_selectable_formats = 197 SND_SOC_POSSIBLE_DAIFMT_DSP_A | 198 SND_SOC_POSSIBLE_DAIFMT_IB_IF; 199 200 static const struct snd_soc_dai_ops ad1836_dai_ops = { 201 .hw_params = ad1836_hw_params, 202 .set_fmt = ad1836_set_dai_fmt, 203 .auto_selectable_formats = &ad1836_selectable_formats, 204 .num_auto_selectable_formats = 1, 205 }; 206 207 #define AD183X_DAI(_name, num_dacs, num_adcs) \ 208 { \ 209 .name = _name "-hifi", \ 210 .playback = { \ 211 .stream_name = "Playback", \ 212 .channels_min = 2, \ 213 .channels_max = (num_dacs) * 2, \ 214 .rates = SNDRV_PCM_RATE_48000, \ 215 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | \ 216 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, \ 217 }, \ 218 .capture = { \ 219 .stream_name = "Capture", \ 220 .channels_min = 2, \ 221 .channels_max = (num_adcs) * 2, \ 222 .rates = SNDRV_PCM_RATE_48000, \ 223 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | \ 224 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, \ 225 }, \ 226 .ops = &ad1836_dai_ops, \ 227 } 228 229 static struct snd_soc_dai_driver ad183x_dais[] = { 230 [AD1835] = AD183X_DAI("ad1835", 4, 1), 231 [AD1836] = AD183X_DAI("ad1836", 3, 2), 232 [AD1838] = AD183X_DAI("ad1838", 3, 1), 233 }; 234 235 #ifdef CONFIG_PM 236 static int ad1836_suspend(struct snd_soc_component *component) 237 { 238 struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component); 239 /* reset clock control mode */ 240 return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, 241 AD1836_ADC_SERFMT_MASK, 0); 242 } 243 244 static int ad1836_resume(struct snd_soc_component *component) 245 { 246 struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component); 247 /* restore clock control mode */ 248 return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, 249 AD1836_ADC_SERFMT_MASK, AD1836_ADC_AUX); 250 } 251 #else 252 #define ad1836_suspend NULL 253 #define ad1836_resume NULL 254 #endif 255 256 static int ad1836_probe(struct snd_soc_component *component) 257 { 258 struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component); 259 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component); 260 int num_dacs, num_adcs; 261 int ret = 0; 262 int i; 263 264 num_dacs = ad183x_dais[ad1836->type].playback.channels_max / 2; 265 num_adcs = ad183x_dais[ad1836->type].capture.channels_max / 2; 266 267 /* default setting for ad1836 */ 268 /* de-emphasis: 48kHz, power-on dac */ 269 regmap_write(ad1836->regmap, AD1836_DAC_CTRL1, 0x300); 270 /* unmute dac channels */ 271 regmap_write(ad1836->regmap, AD1836_DAC_CTRL2, 0x0); 272 /* high-pass filter enable, power-on adc */ 273 regmap_write(ad1836->regmap, AD1836_ADC_CTRL1, 0x100); 274 /* unmute adc channles, adc aux mode */ 275 regmap_write(ad1836->regmap, AD1836_ADC_CTRL2, 0x180); 276 /* volume */ 277 for (i = 1; i <= num_dacs; ++i) { 278 regmap_write(ad1836->regmap, AD1836_DAC_L_VOL(i), 0x3FF); 279 regmap_write(ad1836->regmap, AD1836_DAC_R_VOL(i), 0x3FF); 280 } 281 282 if (ad1836->type == AD1836) { 283 /* left/right diff:PGA/MUX */ 284 regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x3A); 285 ret = snd_soc_add_component_controls(component, ad1836_controls, 286 ARRAY_SIZE(ad1836_controls)); 287 if (ret) 288 return ret; 289 } else { 290 regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x00); 291 } 292 293 ret = snd_soc_add_component_controls(component, ad183x_dac_controls, num_dacs * 2); 294 if (ret) 295 return ret; 296 297 ret = snd_soc_add_component_controls(component, ad183x_adc_controls, num_adcs); 298 if (ret) 299 return ret; 300 301 ret = snd_soc_dapm_new_controls(dapm, ad183x_dac_dapm_widgets, num_dacs); 302 if (ret) 303 return ret; 304 305 ret = snd_soc_dapm_new_controls(dapm, ad183x_adc_dapm_widgets, num_adcs); 306 if (ret) 307 return ret; 308 309 ret = snd_soc_dapm_add_routes(dapm, ad183x_dac_routes, num_dacs); 310 if (ret) 311 return ret; 312 313 ret = snd_soc_dapm_add_routes(dapm, ad183x_adc_routes, num_adcs); 314 315 return ret; 316 } 317 318 /* power down chip */ 319 static void ad1836_remove(struct snd_soc_component *component) 320 { 321 struct ad1836_priv *ad1836 = snd_soc_component_get_drvdata(component); 322 /* reset clock control mode */ 323 regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, 324 AD1836_ADC_SERFMT_MASK, 0); 325 } 326 327 static const struct snd_soc_component_driver soc_component_dev_ad1836 = { 328 .probe = ad1836_probe, 329 .remove = ad1836_remove, 330 .suspend = ad1836_suspend, 331 .resume = ad1836_resume, 332 .controls = ad183x_controls, 333 .num_controls = ARRAY_SIZE(ad183x_controls), 334 .dapm_widgets = ad183x_dapm_widgets, 335 .num_dapm_widgets = ARRAY_SIZE(ad183x_dapm_widgets), 336 .dapm_routes = ad183x_dapm_routes, 337 .num_dapm_routes = ARRAY_SIZE(ad183x_dapm_routes), 338 .idle_bias_on = 1, 339 .use_pmdown_time = 1, 340 .endianness = 1, 341 }; 342 343 static const struct reg_default ad1836_reg_defaults[] = { 344 { AD1836_DAC_CTRL1, 0x0000 }, 345 { AD1836_DAC_CTRL2, 0x0000 }, 346 { AD1836_DAC_L_VOL(0), 0x0000 }, 347 { AD1836_DAC_R_VOL(0), 0x0000 }, 348 { AD1836_DAC_L_VOL(1), 0x0000 }, 349 { AD1836_DAC_R_VOL(1), 0x0000 }, 350 { AD1836_DAC_L_VOL(2), 0x0000 }, 351 { AD1836_DAC_R_VOL(2), 0x0000 }, 352 { AD1836_DAC_L_VOL(3), 0x0000 }, 353 { AD1836_DAC_R_VOL(3), 0x0000 }, 354 { AD1836_ADC_CTRL1, 0x0000 }, 355 { AD1836_ADC_CTRL2, 0x0000 }, 356 { AD1836_ADC_CTRL3, 0x0000 }, 357 }; 358 359 static const struct regmap_config ad1836_regmap_config = { 360 .val_bits = 12, 361 .reg_bits = 4, 362 .read_flag_mask = 0x08, 363 364 .max_register = AD1836_ADC_CTRL3, 365 .reg_defaults = ad1836_reg_defaults, 366 .num_reg_defaults = ARRAY_SIZE(ad1836_reg_defaults), 367 .cache_type = REGCACHE_MAPLE, 368 }; 369 370 static int ad1836_spi_probe(struct spi_device *spi) 371 { 372 struct ad1836_priv *ad1836; 373 int ret; 374 375 ad1836 = devm_kzalloc(&spi->dev, sizeof(struct ad1836_priv), 376 GFP_KERNEL); 377 if (ad1836 == NULL) 378 return -ENOMEM; 379 380 ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config); 381 if (IS_ERR(ad1836->regmap)) 382 return PTR_ERR(ad1836->regmap); 383 384 ad1836->type = spi_get_device_id(spi)->driver_data; 385 386 spi_set_drvdata(spi, ad1836); 387 388 ret = devm_snd_soc_register_component(&spi->dev, 389 &soc_component_dev_ad1836, &ad183x_dais[ad1836->type], 1); 390 return ret; 391 } 392 393 static const struct spi_device_id ad1836_ids[] = { 394 { "ad1835", AD1835 }, 395 { "ad1836", AD1836 }, 396 { "ad1837", AD1835 }, 397 { "ad1838", AD1838 }, 398 { "ad1839", AD1838 }, 399 { }, 400 }; 401 MODULE_DEVICE_TABLE(spi, ad1836_ids); 402 403 static struct spi_driver ad1836_spi_driver = { 404 .driver = { 405 .name = "ad1836", 406 }, 407 .probe = ad1836_spi_probe, 408 .id_table = ad1836_ids, 409 }; 410 411 module_spi_driver(ad1836_spi_driver); 412 413 MODULE_DESCRIPTION("ASoC ad1836 driver"); 414 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 415 MODULE_LICENSE("GPL"); 416