1 /* 2 * Driver for ADAU1701 SigmaDSP processor 3 * 4 * Copyright 2011 Analog Devices Inc. 5 * Author: Lars-Peter Clausen <lars@metafoo.de> 6 * based on an inital version by Cliff Cai <cliff.cai@analog.com> 7 * 8 * Licensed under the GPL-2 or later. 9 */ 10 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/i2c.h> 14 #include <linux/delay.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/soc.h> 20 21 #include "sigmadsp.h" 22 #include "adau1701.h" 23 24 #define ADAU1701_DSPCTRL 0x1c 25 #define ADAU1701_SEROCTL 0x1e 26 #define ADAU1701_SERICTL 0x1f 27 28 #define ADAU1701_AUXNPOW 0x22 29 30 #define ADAU1701_OSCIPOW 0x26 31 #define ADAU1701_DACSET 0x27 32 33 #define ADAU1701_NUM_REGS 0x28 34 35 #define ADAU1701_DSPCTRL_CR (1 << 2) 36 #define ADAU1701_DSPCTRL_DAM (1 << 3) 37 #define ADAU1701_DSPCTRL_ADM (1 << 4) 38 #define ADAU1701_DSPCTRL_SR_48 0x00 39 #define ADAU1701_DSPCTRL_SR_96 0x01 40 #define ADAU1701_DSPCTRL_SR_192 0x02 41 #define ADAU1701_DSPCTRL_SR_MASK 0x03 42 43 #define ADAU1701_SEROCTL_INV_LRCLK 0x2000 44 #define ADAU1701_SEROCTL_INV_BCLK 0x1000 45 #define ADAU1701_SEROCTL_MASTER 0x0800 46 47 #define ADAU1701_SEROCTL_OBF16 0x0000 48 #define ADAU1701_SEROCTL_OBF8 0x0200 49 #define ADAU1701_SEROCTL_OBF4 0x0400 50 #define ADAU1701_SEROCTL_OBF2 0x0600 51 #define ADAU1701_SEROCTL_OBF_MASK 0x0600 52 53 #define ADAU1701_SEROCTL_OLF1024 0x0000 54 #define ADAU1701_SEROCTL_OLF512 0x0080 55 #define ADAU1701_SEROCTL_OLF256 0x0100 56 #define ADAU1701_SEROCTL_OLF_MASK 0x0180 57 58 #define ADAU1701_SEROCTL_MSB_DEALY1 0x0000 59 #define ADAU1701_SEROCTL_MSB_DEALY0 0x0004 60 #define ADAU1701_SEROCTL_MSB_DEALY8 0x0008 61 #define ADAU1701_SEROCTL_MSB_DEALY12 0x000c 62 #define ADAU1701_SEROCTL_MSB_DEALY16 0x0010 63 #define ADAU1701_SEROCTL_MSB_DEALY_MASK 0x001c 64 65 #define ADAU1701_SEROCTL_WORD_LEN_24 0x0000 66 #define ADAU1701_SEROCTL_WORD_LEN_20 0x0001 67 #define ADAU1701_SEROCTL_WORD_LEN_16 0x0010 68 #define ADAU1701_SEROCTL_WORD_LEN_MASK 0x0003 69 70 #define ADAU1701_AUXNPOW_VBPD 0x40 71 #define ADAU1701_AUXNPOW_VRPD 0x20 72 73 #define ADAU1701_SERICTL_I2S 0 74 #define ADAU1701_SERICTL_LEFTJ 1 75 #define ADAU1701_SERICTL_TDM 2 76 #define ADAU1701_SERICTL_RIGHTJ_24 3 77 #define ADAU1701_SERICTL_RIGHTJ_20 4 78 #define ADAU1701_SERICTL_RIGHTJ_18 5 79 #define ADAU1701_SERICTL_RIGHTJ_16 6 80 #define ADAU1701_SERICTL_MODE_MASK 7 81 #define ADAU1701_SERICTL_INV_BCLK BIT(3) 82 #define ADAU1701_SERICTL_INV_LRCLK BIT(4) 83 84 #define ADAU1701_OSCIPOW_OPD 0x04 85 #define ADAU1701_DACSET_DACINIT 1 86 87 #define ADAU1701_FIRMWARE "adau1701.bin" 88 89 struct adau1701 { 90 unsigned int dai_fmt; 91 }; 92 93 static const struct snd_kcontrol_new adau1701_controls[] = { 94 SOC_SINGLE("Master Capture Switch", ADAU1701_DSPCTRL, 4, 1, 0), 95 }; 96 97 static const struct snd_soc_dapm_widget adau1701_dapm_widgets[] = { 98 SND_SOC_DAPM_DAC("DAC0", "Playback", ADAU1701_AUXNPOW, 3, 1), 99 SND_SOC_DAPM_DAC("DAC1", "Playback", ADAU1701_AUXNPOW, 2, 1), 100 SND_SOC_DAPM_DAC("DAC2", "Playback", ADAU1701_AUXNPOW, 1, 1), 101 SND_SOC_DAPM_DAC("DAC3", "Playback", ADAU1701_AUXNPOW, 0, 1), 102 SND_SOC_DAPM_ADC("ADC", "Capture", ADAU1701_AUXNPOW, 7, 1), 103 104 SND_SOC_DAPM_OUTPUT("OUT0"), 105 SND_SOC_DAPM_OUTPUT("OUT1"), 106 SND_SOC_DAPM_OUTPUT("OUT2"), 107 SND_SOC_DAPM_OUTPUT("OUT3"), 108 SND_SOC_DAPM_INPUT("IN0"), 109 SND_SOC_DAPM_INPUT("IN1"), 110 }; 111 112 static const struct snd_soc_dapm_route adau1701_dapm_routes[] = { 113 { "OUT0", NULL, "DAC0" }, 114 { "OUT1", NULL, "DAC1" }, 115 { "OUT2", NULL, "DAC2" }, 116 { "OUT3", NULL, "DAC3" }, 117 118 { "ADC", NULL, "IN0" }, 119 { "ADC", NULL, "IN1" }, 120 }; 121 122 static unsigned int adau1701_register_size(struct snd_soc_codec *codec, 123 unsigned int reg) 124 { 125 switch (reg) { 126 case ADAU1701_DSPCTRL: 127 case ADAU1701_SEROCTL: 128 case ADAU1701_AUXNPOW: 129 case ADAU1701_OSCIPOW: 130 case ADAU1701_DACSET: 131 return 2; 132 case ADAU1701_SERICTL: 133 return 1; 134 } 135 136 dev_err(codec->dev, "Unsupported register address: %d\n", reg); 137 return 0; 138 } 139 140 static int adau1701_write(struct snd_soc_codec *codec, unsigned int reg, 141 unsigned int value) 142 { 143 unsigned int i; 144 unsigned int size; 145 uint8_t buf[4]; 146 int ret; 147 148 size = adau1701_register_size(codec, reg); 149 if (size == 0) 150 return -EINVAL; 151 152 snd_soc_cache_write(codec, reg, value); 153 154 buf[0] = 0x08; 155 buf[1] = reg; 156 157 for (i = size + 1; i >= 2; --i) { 158 buf[i] = value; 159 value >>= 8; 160 } 161 162 ret = i2c_master_send(to_i2c_client(codec->dev), buf, size + 2); 163 if (ret == size + 2) 164 return 0; 165 else if (ret < 0) 166 return ret; 167 else 168 return -EIO; 169 } 170 171 static unsigned int adau1701_read(struct snd_soc_codec *codec, unsigned int reg) 172 { 173 unsigned int value; 174 unsigned int ret; 175 176 ret = snd_soc_cache_read(codec, reg, &value); 177 if (ret) 178 return ret; 179 180 return value; 181 } 182 183 static int adau1701_load_firmware(struct snd_soc_codec *codec) 184 { 185 return process_sigma_firmware(codec->control_data, ADAU1701_FIRMWARE); 186 } 187 188 static int adau1701_set_capture_pcm_format(struct snd_soc_codec *codec, 189 snd_pcm_format_t format) 190 { 191 struct adau1701 *adau1701 = snd_soc_codec_get_drvdata(codec); 192 unsigned int mask = ADAU1701_SEROCTL_WORD_LEN_MASK; 193 unsigned int val; 194 195 switch (format) { 196 case SNDRV_PCM_FORMAT_S16_LE: 197 val = ADAU1701_SEROCTL_WORD_LEN_16; 198 break; 199 case SNDRV_PCM_FORMAT_S20_3LE: 200 val = ADAU1701_SEROCTL_WORD_LEN_20; 201 break; 202 case SNDRV_PCM_FORMAT_S24_LE: 203 val = ADAU1701_SEROCTL_WORD_LEN_24; 204 break; 205 default: 206 return -EINVAL; 207 } 208 209 if (adau1701->dai_fmt == SND_SOC_DAIFMT_RIGHT_J) { 210 switch (format) { 211 case SNDRV_PCM_FORMAT_S16_LE: 212 val |= ADAU1701_SEROCTL_MSB_DEALY16; 213 break; 214 case SNDRV_PCM_FORMAT_S20_3LE: 215 val |= ADAU1701_SEROCTL_MSB_DEALY12; 216 break; 217 case SNDRV_PCM_FORMAT_S24_LE: 218 val |= ADAU1701_SEROCTL_MSB_DEALY8; 219 break; 220 } 221 mask |= ADAU1701_SEROCTL_MSB_DEALY_MASK; 222 } 223 224 snd_soc_update_bits(codec, ADAU1701_SEROCTL, mask, val); 225 226 return 0; 227 } 228 229 static int adau1701_set_playback_pcm_format(struct snd_soc_codec *codec, 230 snd_pcm_format_t format) 231 { 232 struct adau1701 *adau1701 = snd_soc_codec_get_drvdata(codec); 233 unsigned int val; 234 235 if (adau1701->dai_fmt != SND_SOC_DAIFMT_RIGHT_J) 236 return 0; 237 238 switch (format) { 239 case SNDRV_PCM_FORMAT_S16_LE: 240 val = ADAU1701_SERICTL_RIGHTJ_16; 241 break; 242 case SNDRV_PCM_FORMAT_S20_3LE: 243 val = ADAU1701_SERICTL_RIGHTJ_20; 244 break; 245 case SNDRV_PCM_FORMAT_S24_LE: 246 val = ADAU1701_SERICTL_RIGHTJ_24; 247 break; 248 default: 249 return -EINVAL; 250 } 251 252 snd_soc_update_bits(codec, ADAU1701_SERICTL, 253 ADAU1701_SERICTL_MODE_MASK, val); 254 255 return 0; 256 } 257 258 static int adau1701_hw_params(struct snd_pcm_substream *substream, 259 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 260 { 261 struct snd_soc_pcm_runtime *rtd = substream->private_data; 262 struct snd_soc_codec *codec = rtd->codec; 263 snd_pcm_format_t format; 264 unsigned int val; 265 266 switch (params_rate(params)) { 267 case 192000: 268 val = ADAU1701_DSPCTRL_SR_192; 269 break; 270 case 96000: 271 val = ADAU1701_DSPCTRL_SR_96; 272 break; 273 case 48000: 274 val = ADAU1701_DSPCTRL_SR_48; 275 break; 276 default: 277 return -EINVAL; 278 } 279 280 snd_soc_update_bits(codec, ADAU1701_DSPCTRL, 281 ADAU1701_DSPCTRL_SR_MASK, val); 282 283 format = params_format(params); 284 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 285 return adau1701_set_playback_pcm_format(codec, format); 286 else 287 return adau1701_set_capture_pcm_format(codec, format); 288 } 289 290 static int adau1701_set_dai_fmt(struct snd_soc_dai *codec_dai, 291 unsigned int fmt) 292 { 293 struct snd_soc_codec *codec = codec_dai->codec; 294 struct adau1701 *adau1701 = snd_soc_codec_get_drvdata(codec); 295 unsigned int serictl = 0x00, seroctl = 0x00; 296 bool invert_lrclk; 297 298 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 299 case SND_SOC_DAIFMT_CBM_CFM: 300 /* master, 64-bits per sample, 1 frame per sample */ 301 seroctl |= ADAU1701_SEROCTL_MASTER | ADAU1701_SEROCTL_OBF16 302 | ADAU1701_SEROCTL_OLF1024; 303 break; 304 case SND_SOC_DAIFMT_CBS_CFS: 305 break; 306 default: 307 return -EINVAL; 308 } 309 310 /* clock inversion */ 311 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 312 case SND_SOC_DAIFMT_NB_NF: 313 invert_lrclk = false; 314 break; 315 case SND_SOC_DAIFMT_NB_IF: 316 invert_lrclk = true; 317 break; 318 case SND_SOC_DAIFMT_IB_NF: 319 invert_lrclk = false; 320 serictl |= ADAU1701_SERICTL_INV_BCLK; 321 seroctl |= ADAU1701_SEROCTL_INV_BCLK; 322 break; 323 case SND_SOC_DAIFMT_IB_IF: 324 invert_lrclk = true; 325 serictl |= ADAU1701_SERICTL_INV_BCLK; 326 seroctl |= ADAU1701_SEROCTL_INV_BCLK; 327 break; 328 default: 329 return -EINVAL; 330 } 331 332 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 333 case SND_SOC_DAIFMT_I2S: 334 break; 335 case SND_SOC_DAIFMT_LEFT_J: 336 serictl |= ADAU1701_SERICTL_LEFTJ; 337 seroctl |= ADAU1701_SEROCTL_MSB_DEALY0; 338 invert_lrclk = !invert_lrclk; 339 break; 340 case SND_SOC_DAIFMT_RIGHT_J: 341 serictl |= ADAU1701_SERICTL_RIGHTJ_24; 342 seroctl |= ADAU1701_SEROCTL_MSB_DEALY8; 343 invert_lrclk = !invert_lrclk; 344 break; 345 default: 346 return -EINVAL; 347 } 348 349 if (invert_lrclk) { 350 seroctl |= ADAU1701_SEROCTL_INV_LRCLK; 351 serictl |= ADAU1701_SERICTL_INV_LRCLK; 352 } 353 354 adau1701->dai_fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK; 355 356 snd_soc_write(codec, ADAU1701_SERICTL, serictl); 357 snd_soc_update_bits(codec, ADAU1701_SEROCTL, 358 ~ADAU1701_SEROCTL_WORD_LEN_MASK, seroctl); 359 360 return 0; 361 } 362 363 static int adau1701_set_bias_level(struct snd_soc_codec *codec, 364 enum snd_soc_bias_level level) 365 { 366 unsigned int mask = ADAU1701_AUXNPOW_VBPD | ADAU1701_AUXNPOW_VRPD; 367 368 switch (level) { 369 case SND_SOC_BIAS_ON: 370 break; 371 case SND_SOC_BIAS_PREPARE: 372 break; 373 case SND_SOC_BIAS_STANDBY: 374 /* Enable VREF and VREF buffer */ 375 snd_soc_update_bits(codec, ADAU1701_AUXNPOW, mask, 0x00); 376 break; 377 case SND_SOC_BIAS_OFF: 378 /* Disable VREF and VREF buffer */ 379 snd_soc_update_bits(codec, ADAU1701_AUXNPOW, mask, mask); 380 break; 381 } 382 383 codec->dapm.bias_level = level; 384 return 0; 385 } 386 387 static int adau1701_digital_mute(struct snd_soc_dai *dai, int mute) 388 { 389 struct snd_soc_codec *codec = dai->codec; 390 unsigned int mask = ADAU1701_DSPCTRL_DAM; 391 unsigned int val; 392 393 if (mute) 394 val = 0; 395 else 396 val = mask; 397 398 snd_soc_update_bits(codec, ADAU1701_DSPCTRL, mask, val); 399 400 return 0; 401 } 402 403 static int adau1701_set_sysclk(struct snd_soc_codec *codec, int clk_id, 404 int source, unsigned int freq, int dir) 405 { 406 unsigned int val; 407 408 switch (clk_id) { 409 case ADAU1701_CLK_SRC_OSC: 410 val = 0x0; 411 break; 412 case ADAU1701_CLK_SRC_MCLK: 413 val = ADAU1701_OSCIPOW_OPD; 414 break; 415 default: 416 return -EINVAL; 417 } 418 419 snd_soc_update_bits(codec, ADAU1701_OSCIPOW, ADAU1701_OSCIPOW_OPD, val); 420 421 return 0; 422 } 423 424 #define ADAU1701_RATES (SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ 425 SNDRV_PCM_RATE_192000) 426 427 #define ADAU1701_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 428 SNDRV_PCM_FMTBIT_S24_LE) 429 430 static const struct snd_soc_dai_ops adau1701_dai_ops = { 431 .set_fmt = adau1701_set_dai_fmt, 432 .hw_params = adau1701_hw_params, 433 .digital_mute = adau1701_digital_mute, 434 }; 435 436 static struct snd_soc_dai_driver adau1701_dai = { 437 .name = "adau1701", 438 .playback = { 439 .stream_name = "Playback", 440 .channels_min = 2, 441 .channels_max = 8, 442 .rates = ADAU1701_RATES, 443 .formats = ADAU1701_FORMATS, 444 }, 445 .capture = { 446 .stream_name = "Capture", 447 .channels_min = 2, 448 .channels_max = 8, 449 .rates = ADAU1701_RATES, 450 .formats = ADAU1701_FORMATS, 451 }, 452 .ops = &adau1701_dai_ops, 453 .symmetric_rates = 1, 454 }; 455 456 static int adau1701_probe(struct snd_soc_codec *codec) 457 { 458 int ret; 459 460 codec->dapm.idle_bias_off = 1; 461 codec->control_data = to_i2c_client(codec->dev); 462 463 ret = adau1701_load_firmware(codec); 464 if (ret) 465 dev_warn(codec->dev, "Failed to load firmware\n"); 466 467 snd_soc_write(codec, ADAU1701_DACSET, ADAU1701_DACSET_DACINIT); 468 snd_soc_write(codec, ADAU1701_DSPCTRL, ADAU1701_DSPCTRL_CR); 469 470 return 0; 471 } 472 473 static struct snd_soc_codec_driver adau1701_codec_drv = { 474 .probe = adau1701_probe, 475 .set_bias_level = adau1701_set_bias_level, 476 477 .reg_cache_size = ADAU1701_NUM_REGS, 478 .reg_word_size = sizeof(u16), 479 480 .controls = adau1701_controls, 481 .num_controls = ARRAY_SIZE(adau1701_controls), 482 .dapm_widgets = adau1701_dapm_widgets, 483 .num_dapm_widgets = ARRAY_SIZE(adau1701_dapm_widgets), 484 .dapm_routes = adau1701_dapm_routes, 485 .num_dapm_routes = ARRAY_SIZE(adau1701_dapm_routes), 486 487 .write = adau1701_write, 488 .read = adau1701_read, 489 490 .set_sysclk = adau1701_set_sysclk, 491 }; 492 493 static __devinit int adau1701_i2c_probe(struct i2c_client *client, 494 const struct i2c_device_id *id) 495 { 496 struct adau1701 *adau1701; 497 int ret; 498 499 adau1701 = devm_kzalloc(&client->dev, sizeof(*adau1701), GFP_KERNEL); 500 if (!adau1701) 501 return -ENOMEM; 502 503 i2c_set_clientdata(client, adau1701); 504 ret = snd_soc_register_codec(&client->dev, &adau1701_codec_drv, 505 &adau1701_dai, 1); 506 return ret; 507 } 508 509 static __devexit int adau1701_i2c_remove(struct i2c_client *client) 510 { 511 snd_soc_unregister_codec(&client->dev); 512 return 0; 513 } 514 515 static const struct i2c_device_id adau1701_i2c_id[] = { 516 { "adau1701", 0 }, 517 { } 518 }; 519 MODULE_DEVICE_TABLE(i2c, adau1701_i2c_id); 520 521 static struct i2c_driver adau1701_i2c_driver = { 522 .driver = { 523 .name = "adau1701", 524 .owner = THIS_MODULE, 525 }, 526 .probe = adau1701_i2c_probe, 527 .remove = __devexit_p(adau1701_i2c_remove), 528 .id_table = adau1701_i2c_id, 529 }; 530 531 static int __init adau1701_init(void) 532 { 533 return i2c_add_driver(&adau1701_i2c_driver); 534 } 535 module_init(adau1701_init); 536 537 static void __exit adau1701_exit(void) 538 { 539 i2c_del_driver(&adau1701_i2c_driver); 540 } 541 module_exit(adau1701_exit); 542 543 MODULE_DESCRIPTION("ASoC ADAU1701 SigmaDSP driver"); 544 MODULE_AUTHOR("Cliff Cai <cliff.cai@analog.com>"); 545 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 546 MODULE_LICENSE("GPL"); 547