1 /* 2 * AD193X Audio Codec driver supporting AD1936/7/8/9 3 * 4 * Copyright 2010 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 */ 8 9 #include <linux/init.h> 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/device.h> 13 #include <linux/i2c.h> 14 #include <linux/spi/spi.h> 15 #include <linux/slab.h> 16 #include <sound/core.h> 17 #include <sound/pcm.h> 18 #include <sound/pcm_params.h> 19 #include <sound/initval.h> 20 #include <sound/soc.h> 21 #include <sound/tlv.h> 22 #include <sound/soc-dapm.h> 23 #include "ad193x.h" 24 25 /* codec private data */ 26 struct ad193x_priv { 27 u8 reg_cache[AD193X_NUM_REGS]; 28 enum snd_soc_control_type bus_type; 29 void *control_data; 30 int sysclk; 31 }; 32 33 /* ad193x register cache & default register settings */ 34 static const u8 ad193x_reg[AD193X_NUM_REGS] = { 35 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 36 }; 37 38 /* 39 * AD193X volume/mute/de-emphasis etc. controls 40 */ 41 static const char *ad193x_deemp[] = {"None", "48kHz", "44.1kHz", "32kHz"}; 42 43 static const struct soc_enum ad193x_deemp_enum = 44 SOC_ENUM_SINGLE(AD193X_DAC_CTRL2, 1, 4, ad193x_deemp); 45 46 static const struct snd_kcontrol_new ad193x_snd_controls[] = { 47 /* DAC volume control */ 48 SOC_DOUBLE_R("DAC1 Volume", AD193X_DAC_L1_VOL, 49 AD193X_DAC_R1_VOL, 0, 0xFF, 1), 50 SOC_DOUBLE_R("DAC2 Volume", AD193X_DAC_L2_VOL, 51 AD193X_DAC_R2_VOL, 0, 0xFF, 1), 52 SOC_DOUBLE_R("DAC3 Volume", AD193X_DAC_L3_VOL, 53 AD193X_DAC_R3_VOL, 0, 0xFF, 1), 54 SOC_DOUBLE_R("DAC4 Volume", AD193X_DAC_L4_VOL, 55 AD193X_DAC_R4_VOL, 0, 0xFF, 1), 56 57 /* ADC switch control */ 58 SOC_DOUBLE("ADC1 Switch", AD193X_ADC_CTRL0, AD193X_ADCL1_MUTE, 59 AD193X_ADCR1_MUTE, 1, 1), 60 SOC_DOUBLE("ADC2 Switch", AD193X_ADC_CTRL0, AD193X_ADCL2_MUTE, 61 AD193X_ADCR2_MUTE, 1, 1), 62 63 /* DAC switch control */ 64 SOC_DOUBLE("DAC1 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL1_MUTE, 65 AD193X_DACR1_MUTE, 1, 1), 66 SOC_DOUBLE("DAC2 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL2_MUTE, 67 AD193X_DACR2_MUTE, 1, 1), 68 SOC_DOUBLE("DAC3 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL3_MUTE, 69 AD193X_DACR3_MUTE, 1, 1), 70 SOC_DOUBLE("DAC4 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL4_MUTE, 71 AD193X_DACR4_MUTE, 1, 1), 72 73 /* ADC high-pass filter */ 74 SOC_SINGLE("ADC High Pass Filter Switch", AD193X_ADC_CTRL0, 75 AD193X_ADC_HIGHPASS_FILTER, 1, 0), 76 77 /* DAC de-emphasis */ 78 SOC_ENUM("Playback Deemphasis", ad193x_deemp_enum), 79 }; 80 81 static const struct snd_soc_dapm_widget ad193x_dapm_widgets[] = { 82 SND_SOC_DAPM_DAC("DAC", "Playback", AD193X_DAC_CTRL0, 0, 1), 83 SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0), 84 SND_SOC_DAPM_SUPPLY("PLL_PWR", AD193X_PLL_CLK_CTRL0, 0, 1, NULL, 0), 85 SND_SOC_DAPM_SUPPLY("ADC_PWR", AD193X_ADC_CTRL0, 0, 1, NULL, 0), 86 SND_SOC_DAPM_OUTPUT("DAC1OUT"), 87 SND_SOC_DAPM_OUTPUT("DAC2OUT"), 88 SND_SOC_DAPM_OUTPUT("DAC3OUT"), 89 SND_SOC_DAPM_OUTPUT("DAC4OUT"), 90 SND_SOC_DAPM_INPUT("ADC1IN"), 91 SND_SOC_DAPM_INPUT("ADC2IN"), 92 }; 93 94 static const struct snd_soc_dapm_route audio_paths[] = { 95 { "DAC", NULL, "PLL_PWR" }, 96 { "ADC", NULL, "PLL_PWR" }, 97 { "DAC", NULL, "ADC_PWR" }, 98 { "ADC", NULL, "ADC_PWR" }, 99 { "DAC1OUT", "DAC1 Switch", "DAC" }, 100 { "DAC2OUT", "DAC2 Switch", "DAC" }, 101 { "DAC3OUT", "DAC3 Switch", "DAC" }, 102 { "DAC4OUT", "DAC4 Switch", "DAC" }, 103 { "ADC", "ADC1 Switch", "ADC1IN" }, 104 { "ADC", "ADC2 Switch", "ADC2IN" }, 105 }; 106 107 /* 108 * DAI ops entries 109 */ 110 111 static int ad193x_mute(struct snd_soc_dai *dai, int mute) 112 { 113 struct snd_soc_codec *codec = dai->codec; 114 int reg; 115 116 reg = snd_soc_read(codec, AD193X_DAC_CTRL2); 117 reg = (mute > 0) ? reg | AD193X_DAC_MASTER_MUTE : reg & 118 (~AD193X_DAC_MASTER_MUTE); 119 snd_soc_write(codec, AD193X_DAC_CTRL2, reg); 120 121 return 0; 122 } 123 124 static int ad193x_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, 125 unsigned int rx_mask, int slots, int width) 126 { 127 struct snd_soc_codec *codec = dai->codec; 128 int dac_reg = snd_soc_read(codec, AD193X_DAC_CTRL1); 129 int adc_reg = snd_soc_read(codec, AD193X_ADC_CTRL2); 130 131 dac_reg &= ~AD193X_DAC_CHAN_MASK; 132 adc_reg &= ~AD193X_ADC_CHAN_MASK; 133 134 switch (slots) { 135 case 2: 136 dac_reg |= AD193X_DAC_2_CHANNELS << AD193X_DAC_CHAN_SHFT; 137 adc_reg |= AD193X_ADC_2_CHANNELS << AD193X_ADC_CHAN_SHFT; 138 break; 139 case 4: 140 dac_reg |= AD193X_DAC_4_CHANNELS << AD193X_DAC_CHAN_SHFT; 141 adc_reg |= AD193X_ADC_4_CHANNELS << AD193X_ADC_CHAN_SHFT; 142 break; 143 case 8: 144 dac_reg |= AD193X_DAC_8_CHANNELS << AD193X_DAC_CHAN_SHFT; 145 adc_reg |= AD193X_ADC_8_CHANNELS << AD193X_ADC_CHAN_SHFT; 146 break; 147 case 16: 148 dac_reg |= AD193X_DAC_16_CHANNELS << AD193X_DAC_CHAN_SHFT; 149 adc_reg |= AD193X_ADC_16_CHANNELS << AD193X_ADC_CHAN_SHFT; 150 break; 151 default: 152 return -EINVAL; 153 } 154 155 snd_soc_write(codec, AD193X_DAC_CTRL1, dac_reg); 156 snd_soc_write(codec, AD193X_ADC_CTRL2, adc_reg); 157 158 return 0; 159 } 160 161 static int ad193x_set_dai_fmt(struct snd_soc_dai *codec_dai, 162 unsigned int fmt) 163 { 164 struct snd_soc_codec *codec = codec_dai->codec; 165 int adc_reg1, adc_reg2, dac_reg; 166 167 adc_reg1 = snd_soc_read(codec, AD193X_ADC_CTRL1); 168 adc_reg2 = snd_soc_read(codec, AD193X_ADC_CTRL2); 169 dac_reg = snd_soc_read(codec, AD193X_DAC_CTRL1); 170 171 /* At present, the driver only support AUX ADC mode(SND_SOC_DAIFMT_I2S 172 * with TDM) and ADC&DAC TDM mode(SND_SOC_DAIFMT_DSP_A) 173 */ 174 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 175 case SND_SOC_DAIFMT_I2S: 176 adc_reg1 &= ~AD193X_ADC_SERFMT_MASK; 177 adc_reg1 |= AD193X_ADC_SERFMT_TDM; 178 break; 179 case SND_SOC_DAIFMT_DSP_A: 180 adc_reg1 &= ~AD193X_ADC_SERFMT_MASK; 181 adc_reg1 |= AD193X_ADC_SERFMT_AUX; 182 break; 183 default: 184 return -EINVAL; 185 } 186 187 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 188 case SND_SOC_DAIFMT_NB_NF: /* normal bit clock + frame */ 189 adc_reg2 &= ~AD193X_ADC_LEFT_HIGH; 190 adc_reg2 &= ~AD193X_ADC_BCLK_INV; 191 dac_reg &= ~AD193X_DAC_LEFT_HIGH; 192 dac_reg &= ~AD193X_DAC_BCLK_INV; 193 break; 194 case SND_SOC_DAIFMT_NB_IF: /* normal bclk + invert frm */ 195 adc_reg2 |= AD193X_ADC_LEFT_HIGH; 196 adc_reg2 &= ~AD193X_ADC_BCLK_INV; 197 dac_reg |= AD193X_DAC_LEFT_HIGH; 198 dac_reg &= ~AD193X_DAC_BCLK_INV; 199 break; 200 case SND_SOC_DAIFMT_IB_NF: /* invert bclk + normal frm */ 201 adc_reg2 &= ~AD193X_ADC_LEFT_HIGH; 202 adc_reg2 |= AD193X_ADC_BCLK_INV; 203 dac_reg &= ~AD193X_DAC_LEFT_HIGH; 204 dac_reg |= AD193X_DAC_BCLK_INV; 205 break; 206 207 case SND_SOC_DAIFMT_IB_IF: /* invert bclk + frm */ 208 adc_reg2 |= AD193X_ADC_LEFT_HIGH; 209 adc_reg2 |= AD193X_ADC_BCLK_INV; 210 dac_reg |= AD193X_DAC_LEFT_HIGH; 211 dac_reg |= AD193X_DAC_BCLK_INV; 212 break; 213 default: 214 return -EINVAL; 215 } 216 217 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 218 case SND_SOC_DAIFMT_CBM_CFM: /* codec clk & frm master */ 219 adc_reg2 |= AD193X_ADC_LCR_MASTER; 220 adc_reg2 |= AD193X_ADC_BCLK_MASTER; 221 dac_reg |= AD193X_DAC_LCR_MASTER; 222 dac_reg |= AD193X_DAC_BCLK_MASTER; 223 break; 224 case SND_SOC_DAIFMT_CBS_CFM: /* codec clk slave & frm master */ 225 adc_reg2 |= AD193X_ADC_LCR_MASTER; 226 adc_reg2 &= ~AD193X_ADC_BCLK_MASTER; 227 dac_reg |= AD193X_DAC_LCR_MASTER; 228 dac_reg &= ~AD193X_DAC_BCLK_MASTER; 229 break; 230 case SND_SOC_DAIFMT_CBM_CFS: /* codec clk master & frame slave */ 231 adc_reg2 &= ~AD193X_ADC_LCR_MASTER; 232 adc_reg2 |= AD193X_ADC_BCLK_MASTER; 233 dac_reg &= ~AD193X_DAC_LCR_MASTER; 234 dac_reg |= AD193X_DAC_BCLK_MASTER; 235 break; 236 case SND_SOC_DAIFMT_CBS_CFS: /* codec clk & frm slave */ 237 adc_reg2 &= ~AD193X_ADC_LCR_MASTER; 238 adc_reg2 &= ~AD193X_ADC_BCLK_MASTER; 239 dac_reg &= ~AD193X_DAC_LCR_MASTER; 240 dac_reg &= ~AD193X_DAC_BCLK_MASTER; 241 break; 242 default: 243 return -EINVAL; 244 } 245 246 snd_soc_write(codec, AD193X_ADC_CTRL1, adc_reg1); 247 snd_soc_write(codec, AD193X_ADC_CTRL2, adc_reg2); 248 snd_soc_write(codec, AD193X_DAC_CTRL1, dac_reg); 249 250 return 0; 251 } 252 253 static int ad193x_set_dai_sysclk(struct snd_soc_dai *codec_dai, 254 int clk_id, unsigned int freq, int dir) 255 { 256 struct snd_soc_codec *codec = codec_dai->codec; 257 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec); 258 switch (freq) { 259 case 12288000: 260 case 18432000: 261 case 24576000: 262 case 36864000: 263 ad193x->sysclk = freq; 264 return 0; 265 } 266 return -EINVAL; 267 } 268 269 static int ad193x_hw_params(struct snd_pcm_substream *substream, 270 struct snd_pcm_hw_params *params, 271 struct snd_soc_dai *dai) 272 { 273 int word_len = 0, reg = 0, master_rate = 0; 274 275 struct snd_soc_pcm_runtime *rtd = substream->private_data; 276 struct snd_soc_codec *codec = rtd->codec; 277 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec); 278 279 /* bit size */ 280 switch (params_format(params)) { 281 case SNDRV_PCM_FORMAT_S16_LE: 282 word_len = 3; 283 break; 284 case SNDRV_PCM_FORMAT_S20_3LE: 285 word_len = 1; 286 break; 287 case SNDRV_PCM_FORMAT_S24_LE: 288 case SNDRV_PCM_FORMAT_S32_LE: 289 word_len = 0; 290 break; 291 } 292 293 switch (ad193x->sysclk) { 294 case 12288000: 295 master_rate = AD193X_PLL_INPUT_256; 296 break; 297 case 18432000: 298 master_rate = AD193X_PLL_INPUT_384; 299 break; 300 case 24576000: 301 master_rate = AD193X_PLL_INPUT_512; 302 break; 303 case 36864000: 304 master_rate = AD193X_PLL_INPUT_768; 305 break; 306 } 307 308 reg = snd_soc_read(codec, AD193X_PLL_CLK_CTRL0); 309 reg = (reg & AD193X_PLL_INPUT_MASK) | master_rate; 310 snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, reg); 311 312 reg = snd_soc_read(codec, AD193X_DAC_CTRL2); 313 reg = (reg & (~AD193X_DAC_WORD_LEN_MASK)) | word_len; 314 snd_soc_write(codec, AD193X_DAC_CTRL2, reg); 315 316 reg = snd_soc_read(codec, AD193X_ADC_CTRL1); 317 reg = (reg & (~AD193X_ADC_WORD_LEN_MASK)) | word_len; 318 snd_soc_write(codec, AD193X_ADC_CTRL1, reg); 319 320 return 0; 321 } 322 323 static struct snd_soc_dai_ops ad193x_dai_ops = { 324 .hw_params = ad193x_hw_params, 325 .digital_mute = ad193x_mute, 326 .set_tdm_slot = ad193x_set_tdm_slot, 327 .set_sysclk = ad193x_set_dai_sysclk, 328 .set_fmt = ad193x_set_dai_fmt, 329 }; 330 331 /* codec DAI instance */ 332 static struct snd_soc_dai_driver ad193x_dai = { 333 .name = "ad193x-hifi", 334 .playback = { 335 .stream_name = "Playback", 336 .channels_min = 2, 337 .channels_max = 8, 338 .rates = SNDRV_PCM_RATE_48000, 339 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | 340 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, 341 }, 342 .capture = { 343 .stream_name = "Capture", 344 .channels_min = 2, 345 .channels_max = 4, 346 .rates = SNDRV_PCM_RATE_48000, 347 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE | 348 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE, 349 }, 350 .ops = &ad193x_dai_ops, 351 }; 352 353 static int ad193x_probe(struct snd_soc_codec *codec) 354 { 355 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec); 356 int ret; 357 358 codec->control_data = ad193x->control_data; 359 if (ad193x->bus_type == SND_SOC_I2C) 360 ret = snd_soc_codec_set_cache_io(codec, 8, 8, ad193x->bus_type); 361 else 362 ret = snd_soc_codec_set_cache_io(codec, 16, 8, ad193x->bus_type); 363 if (ret < 0) { 364 dev_err(codec->dev, "failed to set cache I/O: %d\n", 365 ret); 366 kfree(ad193x); 367 return ret; 368 } 369 370 /* default setting for ad193x */ 371 372 /* unmute dac channels */ 373 snd_soc_write(codec, AD193X_DAC_CHNL_MUTE, 0x0); 374 /* de-emphasis: 48kHz, powedown dac */ 375 snd_soc_write(codec, AD193X_DAC_CTRL2, 0x1A); 376 /* powerdown dac, dac in tdm mode */ 377 snd_soc_write(codec, AD193X_DAC_CTRL0, 0x41); 378 /* high-pass filter enable */ 379 snd_soc_write(codec, AD193X_ADC_CTRL0, 0x3); 380 /* sata delay=1, adc aux mode */ 381 snd_soc_write(codec, AD193X_ADC_CTRL1, 0x43); 382 /* pll input: mclki/xi */ 383 snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, 0x99); /* mclk=24.576Mhz: 0x9D; mclk=12.288Mhz: 0x99 */ 384 snd_soc_write(codec, AD193X_PLL_CLK_CTRL1, 0x04); 385 386 snd_soc_add_controls(codec, ad193x_snd_controls, 387 ARRAY_SIZE(ad193x_snd_controls)); 388 snd_soc_dapm_new_controls(codec, ad193x_dapm_widgets, 389 ARRAY_SIZE(ad193x_dapm_widgets)); 390 snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths)); 391 392 return ret; 393 } 394 395 static struct snd_soc_codec_driver soc_codec_dev_ad193x = { 396 .probe = ad193x_probe, 397 .reg_cache_default = ad193x_reg, 398 .reg_cache_size = AD193X_NUM_REGS, 399 .reg_word_size = sizeof(u16), 400 }; 401 402 #if defined(CONFIG_SPI_MASTER) 403 static int __devinit ad193x_spi_probe(struct spi_device *spi) 404 { 405 struct ad193x_priv *ad193x; 406 int ret; 407 408 ad193x = kzalloc(sizeof(struct ad193x_priv), GFP_KERNEL); 409 if (ad193x == NULL) 410 return -ENOMEM; 411 412 spi_set_drvdata(spi, ad193x); 413 ad193x->control_data = spi; 414 ad193x->bus_type = SND_SOC_SPI; 415 416 ret = snd_soc_register_codec(&spi->dev, 417 &soc_codec_dev_ad193x, &ad193x_dai, 1); 418 if (ret < 0) 419 kfree(ad193x); 420 return ret; 421 } 422 423 static int __devexit ad193x_spi_remove(struct spi_device *spi) 424 { 425 snd_soc_unregister_codec(&spi->dev); 426 kfree(spi_get_drvdata(spi)); 427 return 0; 428 } 429 430 static struct spi_driver ad193x_spi_driver = { 431 .driver = { 432 .name = "ad193x-codec", 433 .owner = THIS_MODULE, 434 }, 435 .probe = ad193x_spi_probe, 436 .remove = __devexit_p(ad193x_spi_remove), 437 }; 438 #endif 439 440 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 441 static const struct i2c_device_id ad193x_id[] = { 442 { "ad1936", 0 }, 443 { "ad1937", 0 }, 444 { } 445 }; 446 MODULE_DEVICE_TABLE(i2c, ad193x_id); 447 448 static int __devinit ad193x_i2c_probe(struct i2c_client *client, 449 const struct i2c_device_id *id) 450 { 451 struct ad193x_priv *ad193x; 452 int ret; 453 454 ad193x = kzalloc(sizeof(struct ad193x_priv), GFP_KERNEL); 455 if (ad193x == NULL) 456 return -ENOMEM; 457 458 i2c_set_clientdata(client, ad193x); 459 ad193x->control_data = client; 460 ad193x->bus_type = SND_SOC_I2C; 461 462 ret = snd_soc_register_codec(&client->dev, 463 &soc_codec_dev_ad193x, &ad193x_dai, 1); 464 if (ret < 0) 465 kfree(ad193x); 466 return ret; 467 } 468 469 static int __devexit ad193x_i2c_remove(struct i2c_client *client) 470 { 471 snd_soc_unregister_codec(&client->dev); 472 kfree(i2c_get_clientdata(client)); 473 return 0; 474 } 475 476 static struct i2c_driver ad193x_i2c_driver = { 477 .driver = { 478 .name = "ad193x-codec", 479 }, 480 .probe = ad193x_i2c_probe, 481 .remove = __devexit_p(ad193x_i2c_remove), 482 .id_table = ad193x_id, 483 }; 484 #endif 485 486 static int __init ad193x_modinit(void) 487 { 488 int ret; 489 490 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 491 ret = i2c_add_driver(&ad193x_i2c_driver); 492 if (ret != 0) { 493 printk(KERN_ERR "Failed to register AD193X I2C driver: %d\n", 494 ret); 495 } 496 #endif 497 498 #if defined(CONFIG_SPI_MASTER) 499 ret = spi_register_driver(&ad193x_spi_driver); 500 if (ret != 0) { 501 printk(KERN_ERR "Failed to register AD193X SPI driver: %d\n", 502 ret); 503 } 504 #endif 505 return ret; 506 } 507 module_init(ad193x_modinit); 508 509 static void __exit ad193x_modexit(void) 510 { 511 #if defined(CONFIG_SPI_MASTER) 512 spi_unregister_driver(&ad193x_spi_driver); 513 #endif 514 515 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 516 i2c_del_driver(&ad193x_i2c_driver); 517 #endif 518 } 519 module_exit(ad193x_modexit); 520 521 MODULE_DESCRIPTION("ASoC ad193x driver"); 522 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 523 MODULE_LICENSE("GPL"); 524