1 /* 2 * wm8776.c -- WM8776 ALSA SoC Audio driver 3 * 4 * Copyright 2009-12 Wolfson Microelectronics plc 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * TODO: Input ALC/limiter support 13 */ 14 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/init.h> 18 #include <linux/delay.h> 19 #include <linux/pm.h> 20 #include <linux/i2c.h> 21 #include <linux/of_device.h> 22 #include <linux/regmap.h> 23 #include <linux/spi/spi.h> 24 #include <linux/slab.h> 25 #include <sound/core.h> 26 #include <sound/pcm.h> 27 #include <sound/pcm_params.h> 28 #include <sound/soc.h> 29 #include <sound/initval.h> 30 #include <sound/tlv.h> 31 32 #include "wm8776.h" 33 34 enum wm8776_chip_type { 35 WM8775 = 1, 36 WM8776, 37 }; 38 39 /* codec private data */ 40 struct wm8776_priv { 41 struct regmap *regmap; 42 int sysclk[2]; 43 }; 44 45 static const struct reg_default wm8776_reg_defaults[] = { 46 { 0, 0x79 }, 47 { 1, 0x79 }, 48 { 2, 0x79 }, 49 { 3, 0xff }, 50 { 4, 0xff }, 51 { 5, 0xff }, 52 { 6, 0x00 }, 53 { 7, 0x90 }, 54 { 8, 0x00 }, 55 { 9, 0x00 }, 56 { 10, 0x22 }, 57 { 11, 0x22 }, 58 { 12, 0x22 }, 59 { 13, 0x08 }, 60 { 14, 0xcf }, 61 { 15, 0xcf }, 62 { 16, 0x7b }, 63 { 17, 0x00 }, 64 { 18, 0x32 }, 65 { 19, 0x00 }, 66 { 20, 0xa6 }, 67 { 21, 0x01 }, 68 { 22, 0x01 }, 69 }; 70 71 static bool wm8776_volatile(struct device *dev, unsigned int reg) 72 { 73 switch (reg) { 74 case WM8776_RESET: 75 return true; 76 default: 77 return false; 78 } 79 } 80 81 static int wm8776_reset(struct snd_soc_codec *codec) 82 { 83 return snd_soc_write(codec, WM8776_RESET, 0); 84 } 85 86 static const DECLARE_TLV_DB_SCALE(hp_tlv, -12100, 100, 1); 87 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1); 88 static const DECLARE_TLV_DB_SCALE(adc_tlv, -10350, 50, 1); 89 90 static const struct snd_kcontrol_new wm8776_snd_controls[] = { 91 SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8776_HPLVOL, WM8776_HPRVOL, 92 0, 127, 0, hp_tlv), 93 SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8776_DACLVOL, WM8776_DACRVOL, 94 0, 255, 0, dac_tlv), 95 SOC_SINGLE("Digital Playback ZC Switch", WM8776_DACCTRL1, 0, 1, 0), 96 97 SOC_SINGLE("Deemphasis Switch", WM8776_DACCTRL2, 0, 1, 0), 98 99 SOC_DOUBLE_R_TLV("Capture Volume", WM8776_ADCLVOL, WM8776_ADCRVOL, 100 0, 255, 0, adc_tlv), 101 SOC_DOUBLE("Capture Switch", WM8776_ADCMUX, 7, 6, 1, 1), 102 SOC_DOUBLE_R("Capture ZC Switch", WM8776_ADCLVOL, WM8776_ADCRVOL, 8, 1, 0), 103 SOC_SINGLE("Capture HPF Switch", WM8776_ADCIFCTRL, 8, 1, 1), 104 }; 105 106 static const struct snd_kcontrol_new inmix_controls[] = { 107 SOC_DAPM_SINGLE("AIN1 Switch", WM8776_ADCMUX, 0, 1, 0), 108 SOC_DAPM_SINGLE("AIN2 Switch", WM8776_ADCMUX, 1, 1, 0), 109 SOC_DAPM_SINGLE("AIN3 Switch", WM8776_ADCMUX, 2, 1, 0), 110 SOC_DAPM_SINGLE("AIN4 Switch", WM8776_ADCMUX, 3, 1, 0), 111 SOC_DAPM_SINGLE("AIN5 Switch", WM8776_ADCMUX, 4, 1, 0), 112 }; 113 114 static const struct snd_kcontrol_new outmix_controls[] = { 115 SOC_DAPM_SINGLE("DAC Switch", WM8776_OUTMUX, 0, 1, 0), 116 SOC_DAPM_SINGLE("AUX Switch", WM8776_OUTMUX, 1, 1, 0), 117 SOC_DAPM_SINGLE("Bypass Switch", WM8776_OUTMUX, 2, 1, 0), 118 }; 119 120 static const struct snd_soc_dapm_widget wm8776_dapm_widgets[] = { 121 SND_SOC_DAPM_INPUT("AUX"), 122 123 SND_SOC_DAPM_INPUT("AIN1"), 124 SND_SOC_DAPM_INPUT("AIN2"), 125 SND_SOC_DAPM_INPUT("AIN3"), 126 SND_SOC_DAPM_INPUT("AIN4"), 127 SND_SOC_DAPM_INPUT("AIN5"), 128 129 SND_SOC_DAPM_MIXER("Input Mixer", WM8776_PWRDOWN, 6, 1, 130 inmix_controls, ARRAY_SIZE(inmix_controls)), 131 132 SND_SOC_DAPM_ADC("ADC", "Capture", WM8776_PWRDOWN, 1, 1), 133 SND_SOC_DAPM_DAC("DAC", "Playback", WM8776_PWRDOWN, 2, 1), 134 135 SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0, 136 outmix_controls, ARRAY_SIZE(outmix_controls)), 137 138 SND_SOC_DAPM_PGA("Headphone PGA", WM8776_PWRDOWN, 3, 1, NULL, 0), 139 140 SND_SOC_DAPM_OUTPUT("VOUT"), 141 142 SND_SOC_DAPM_OUTPUT("HPOUTL"), 143 SND_SOC_DAPM_OUTPUT("HPOUTR"), 144 }; 145 146 static const struct snd_soc_dapm_route routes[] = { 147 { "Input Mixer", "AIN1 Switch", "AIN1" }, 148 { "Input Mixer", "AIN2 Switch", "AIN2" }, 149 { "Input Mixer", "AIN3 Switch", "AIN3" }, 150 { "Input Mixer", "AIN4 Switch", "AIN4" }, 151 { "Input Mixer", "AIN5 Switch", "AIN5" }, 152 153 { "ADC", NULL, "Input Mixer" }, 154 155 { "Output Mixer", "DAC Switch", "DAC" }, 156 { "Output Mixer", "AUX Switch", "AUX" }, 157 { "Output Mixer", "Bypass Switch", "Input Mixer" }, 158 159 { "VOUT", NULL, "Output Mixer" }, 160 161 { "Headphone PGA", NULL, "Output Mixer" }, 162 163 { "HPOUTL", NULL, "Headphone PGA" }, 164 { "HPOUTR", NULL, "Headphone PGA" }, 165 }; 166 167 static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 168 { 169 struct snd_soc_codec *codec = dai->codec; 170 int reg, iface, master; 171 172 switch (dai->driver->id) { 173 case WM8776_DAI_DAC: 174 reg = WM8776_DACIFCTRL; 175 master = 0x80; 176 break; 177 case WM8776_DAI_ADC: 178 reg = WM8776_ADCIFCTRL; 179 master = 0x100; 180 break; 181 default: 182 return -EINVAL; 183 } 184 185 iface = 0; 186 187 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 188 case SND_SOC_DAIFMT_CBM_CFM: 189 break; 190 case SND_SOC_DAIFMT_CBS_CFS: 191 master = 0; 192 break; 193 default: 194 return -EINVAL; 195 } 196 197 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 198 case SND_SOC_DAIFMT_I2S: 199 iface |= 0x0002; 200 break; 201 case SND_SOC_DAIFMT_RIGHT_J: 202 break; 203 case SND_SOC_DAIFMT_LEFT_J: 204 iface |= 0x0001; 205 break; 206 default: 207 return -EINVAL; 208 } 209 210 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 211 case SND_SOC_DAIFMT_NB_NF: 212 break; 213 case SND_SOC_DAIFMT_IB_IF: 214 iface |= 0x00c; 215 break; 216 case SND_SOC_DAIFMT_IB_NF: 217 iface |= 0x008; 218 break; 219 case SND_SOC_DAIFMT_NB_IF: 220 iface |= 0x004; 221 break; 222 default: 223 return -EINVAL; 224 } 225 226 /* Finally, write out the values */ 227 snd_soc_update_bits(codec, reg, 0xf, iface); 228 snd_soc_update_bits(codec, WM8776_MSTRCTRL, 0x180, master); 229 230 return 0; 231 } 232 233 static int mclk_ratios[] = { 234 128, 235 192, 236 256, 237 384, 238 512, 239 768, 240 }; 241 242 static int wm8776_hw_params(struct snd_pcm_substream *substream, 243 struct snd_pcm_hw_params *params, 244 struct snd_soc_dai *dai) 245 { 246 struct snd_soc_codec *codec = dai->codec; 247 struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec); 248 int iface_reg, iface; 249 int ratio_shift, master; 250 int i; 251 252 switch (dai->driver->id) { 253 case WM8776_DAI_DAC: 254 iface_reg = WM8776_DACIFCTRL; 255 master = 0x80; 256 ratio_shift = 4; 257 break; 258 case WM8776_DAI_ADC: 259 iface_reg = WM8776_ADCIFCTRL; 260 master = 0x100; 261 ratio_shift = 0; 262 break; 263 default: 264 return -EINVAL; 265 } 266 267 /* Set word length */ 268 switch (snd_pcm_format_width(params_format(params))) { 269 case 16: 270 iface = 0; 271 break; 272 case 20: 273 iface = 0x10; 274 break; 275 case 24: 276 iface = 0x20; 277 break; 278 case 32: 279 iface = 0x30; 280 break; 281 default: 282 dev_err(codec->dev, "Unsupported sample size: %i\n", 283 snd_pcm_format_width(params_format(params))); 284 return -EINVAL; 285 } 286 287 /* Only need to set MCLK/LRCLK ratio if we're master */ 288 if (snd_soc_read(codec, WM8776_MSTRCTRL) & master) { 289 for (i = 0; i < ARRAY_SIZE(mclk_ratios); i++) { 290 if (wm8776->sysclk[dai->driver->id] / params_rate(params) 291 == mclk_ratios[i]) 292 break; 293 } 294 295 if (i == ARRAY_SIZE(mclk_ratios)) { 296 dev_err(codec->dev, 297 "Unable to configure MCLK ratio %d/%d\n", 298 wm8776->sysclk[dai->driver->id], params_rate(params)); 299 return -EINVAL; 300 } 301 302 dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]); 303 304 snd_soc_update_bits(codec, WM8776_MSTRCTRL, 305 0x7 << ratio_shift, i << ratio_shift); 306 } else { 307 dev_dbg(codec->dev, "DAI in slave mode\n"); 308 } 309 310 snd_soc_update_bits(codec, iface_reg, 0x30, iface); 311 312 return 0; 313 } 314 315 static int wm8776_mute(struct snd_soc_dai *dai, int mute) 316 { 317 struct snd_soc_codec *codec = dai->codec; 318 319 return snd_soc_write(codec, WM8776_DACMUTE, !!mute); 320 } 321 322 static int wm8776_set_sysclk(struct snd_soc_dai *dai, 323 int clk_id, unsigned int freq, int dir) 324 { 325 struct snd_soc_codec *codec = dai->codec; 326 struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec); 327 328 if (WARN_ON(dai->driver->id >= ARRAY_SIZE(wm8776->sysclk))) 329 return -EINVAL; 330 331 wm8776->sysclk[dai->driver->id] = freq; 332 333 return 0; 334 } 335 336 static int wm8776_set_bias_level(struct snd_soc_codec *codec, 337 enum snd_soc_bias_level level) 338 { 339 struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec); 340 341 switch (level) { 342 case SND_SOC_BIAS_ON: 343 break; 344 case SND_SOC_BIAS_PREPARE: 345 break; 346 case SND_SOC_BIAS_STANDBY: 347 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) { 348 regcache_sync(wm8776->regmap); 349 350 /* Disable the global powerdown; DAPM does the rest */ 351 snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0); 352 } 353 354 break; 355 case SND_SOC_BIAS_OFF: 356 snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 1); 357 break; 358 } 359 360 codec->dapm.bias_level = level; 361 return 0; 362 } 363 364 #define WM8776_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 365 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE) 366 367 static const struct snd_soc_dai_ops wm8776_dac_ops = { 368 .digital_mute = wm8776_mute, 369 .hw_params = wm8776_hw_params, 370 .set_fmt = wm8776_set_fmt, 371 .set_sysclk = wm8776_set_sysclk, 372 }; 373 374 static const struct snd_soc_dai_ops wm8776_adc_ops = { 375 .hw_params = wm8776_hw_params, 376 .set_fmt = wm8776_set_fmt, 377 .set_sysclk = wm8776_set_sysclk, 378 }; 379 380 static struct snd_soc_dai_driver wm8776_dai[] = { 381 { 382 .name = "wm8776-hifi-playback", 383 .id = WM8776_DAI_DAC, 384 .playback = { 385 .stream_name = "Playback", 386 .channels_min = 2, 387 .channels_max = 2, 388 .rates = SNDRV_PCM_RATE_CONTINUOUS, 389 .rate_min = 32000, 390 .rate_max = 192000, 391 .formats = WM8776_FORMATS, 392 }, 393 .ops = &wm8776_dac_ops, 394 }, 395 { 396 .name = "wm8776-hifi-capture", 397 .id = WM8776_DAI_ADC, 398 .capture = { 399 .stream_name = "Capture", 400 .channels_min = 2, 401 .channels_max = 2, 402 .rates = SNDRV_PCM_RATE_CONTINUOUS, 403 .rate_min = 32000, 404 .rate_max = 96000, 405 .formats = WM8776_FORMATS, 406 }, 407 .ops = &wm8776_adc_ops, 408 }, 409 }; 410 411 static int wm8776_probe(struct snd_soc_codec *codec) 412 { 413 int ret = 0; 414 415 ret = wm8776_reset(codec); 416 if (ret < 0) { 417 dev_err(codec->dev, "Failed to issue reset: %d\n", ret); 418 return ret; 419 } 420 421 /* Latch the update bits; right channel only since we always 422 * update both. */ 423 snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100); 424 snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100); 425 426 return ret; 427 } 428 429 static struct snd_soc_codec_driver soc_codec_dev_wm8776 = { 430 .probe = wm8776_probe, 431 .set_bias_level = wm8776_set_bias_level, 432 .suspend_bias_off = true, 433 434 .controls = wm8776_snd_controls, 435 .num_controls = ARRAY_SIZE(wm8776_snd_controls), 436 .dapm_widgets = wm8776_dapm_widgets, 437 .num_dapm_widgets = ARRAY_SIZE(wm8776_dapm_widgets), 438 .dapm_routes = routes, 439 .num_dapm_routes = ARRAY_SIZE(routes), 440 }; 441 442 static const struct of_device_id wm8776_of_match[] = { 443 { .compatible = "wlf,wm8776", }, 444 { } 445 }; 446 MODULE_DEVICE_TABLE(of, wm8776_of_match); 447 448 static const struct regmap_config wm8776_regmap = { 449 .reg_bits = 7, 450 .val_bits = 9, 451 .max_register = WM8776_RESET, 452 453 .reg_defaults = wm8776_reg_defaults, 454 .num_reg_defaults = ARRAY_SIZE(wm8776_reg_defaults), 455 .cache_type = REGCACHE_RBTREE, 456 457 .volatile_reg = wm8776_volatile, 458 }; 459 460 #if defined(CONFIG_SPI_MASTER) 461 static int wm8776_spi_probe(struct spi_device *spi) 462 { 463 struct wm8776_priv *wm8776; 464 int ret; 465 466 wm8776 = devm_kzalloc(&spi->dev, sizeof(struct wm8776_priv), 467 GFP_KERNEL); 468 if (wm8776 == NULL) 469 return -ENOMEM; 470 471 wm8776->regmap = devm_regmap_init_spi(spi, &wm8776_regmap); 472 if (IS_ERR(wm8776->regmap)) 473 return PTR_ERR(wm8776->regmap); 474 475 spi_set_drvdata(spi, wm8776); 476 477 ret = snd_soc_register_codec(&spi->dev, 478 &soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai)); 479 480 return ret; 481 } 482 483 static int wm8776_spi_remove(struct spi_device *spi) 484 { 485 snd_soc_unregister_codec(&spi->dev); 486 return 0; 487 } 488 489 static struct spi_driver wm8776_spi_driver = { 490 .driver = { 491 .name = "wm8776", 492 .owner = THIS_MODULE, 493 .of_match_table = wm8776_of_match, 494 }, 495 .probe = wm8776_spi_probe, 496 .remove = wm8776_spi_remove, 497 }; 498 #endif /* CONFIG_SPI_MASTER */ 499 500 #if IS_ENABLED(CONFIG_I2C) 501 static int wm8776_i2c_probe(struct i2c_client *i2c, 502 const struct i2c_device_id *id) 503 { 504 struct wm8776_priv *wm8776; 505 int ret; 506 507 wm8776 = devm_kzalloc(&i2c->dev, sizeof(struct wm8776_priv), 508 GFP_KERNEL); 509 if (wm8776 == NULL) 510 return -ENOMEM; 511 512 wm8776->regmap = devm_regmap_init_i2c(i2c, &wm8776_regmap); 513 if (IS_ERR(wm8776->regmap)) 514 return PTR_ERR(wm8776->regmap); 515 516 i2c_set_clientdata(i2c, wm8776); 517 518 ret = snd_soc_register_codec(&i2c->dev, 519 &soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai)); 520 521 return ret; 522 } 523 524 static int wm8776_i2c_remove(struct i2c_client *client) 525 { 526 snd_soc_unregister_codec(&client->dev); 527 return 0; 528 } 529 530 static const struct i2c_device_id wm8776_i2c_id[] = { 531 { "wm8775", WM8775 }, 532 { "wm8776", WM8776 }, 533 { } 534 }; 535 MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id); 536 537 static struct i2c_driver wm8776_i2c_driver = { 538 .driver = { 539 .name = "wm8776", 540 .owner = THIS_MODULE, 541 .of_match_table = wm8776_of_match, 542 }, 543 .probe = wm8776_i2c_probe, 544 .remove = wm8776_i2c_remove, 545 .id_table = wm8776_i2c_id, 546 }; 547 #endif 548 549 static int __init wm8776_modinit(void) 550 { 551 int ret = 0; 552 #if IS_ENABLED(CONFIG_I2C) 553 ret = i2c_add_driver(&wm8776_i2c_driver); 554 if (ret != 0) { 555 printk(KERN_ERR "Failed to register wm8776 I2C driver: %d\n", 556 ret); 557 } 558 #endif 559 #if defined(CONFIG_SPI_MASTER) 560 ret = spi_register_driver(&wm8776_spi_driver); 561 if (ret != 0) { 562 printk(KERN_ERR "Failed to register wm8776 SPI driver: %d\n", 563 ret); 564 } 565 #endif 566 return ret; 567 } 568 module_init(wm8776_modinit); 569 570 static void __exit wm8776_exit(void) 571 { 572 #if IS_ENABLED(CONFIG_I2C) 573 i2c_del_driver(&wm8776_i2c_driver); 574 #endif 575 #if defined(CONFIG_SPI_MASTER) 576 spi_unregister_driver(&wm8776_spi_driver); 577 #endif 578 } 579 module_exit(wm8776_exit); 580 581 MODULE_DESCRIPTION("ASoC WM8776 driver"); 582 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 583 MODULE_LICENSE("GPL"); 584