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 (params_width(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 params_width(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 (snd_soc_codec_get_bias_level(codec) == 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 return 0; 361 } 362 363 #define WM8776_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 364 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE) 365 366 static const struct snd_soc_dai_ops wm8776_dac_ops = { 367 .digital_mute = wm8776_mute, 368 .hw_params = wm8776_hw_params, 369 .set_fmt = wm8776_set_fmt, 370 .set_sysclk = wm8776_set_sysclk, 371 }; 372 373 static const struct snd_soc_dai_ops wm8776_adc_ops = { 374 .hw_params = wm8776_hw_params, 375 .set_fmt = wm8776_set_fmt, 376 .set_sysclk = wm8776_set_sysclk, 377 }; 378 379 static struct snd_soc_dai_driver wm8776_dai[] = { 380 { 381 .name = "wm8776-hifi-playback", 382 .id = WM8776_DAI_DAC, 383 .playback = { 384 .stream_name = "Playback", 385 .channels_min = 2, 386 .channels_max = 2, 387 .rates = SNDRV_PCM_RATE_CONTINUOUS, 388 .rate_min = 32000, 389 .rate_max = 192000, 390 .formats = WM8776_FORMATS, 391 }, 392 .ops = &wm8776_dac_ops, 393 }, 394 { 395 .name = "wm8776-hifi-capture", 396 .id = WM8776_DAI_ADC, 397 .capture = { 398 .stream_name = "Capture", 399 .channels_min = 2, 400 .channels_max = 2, 401 .rates = SNDRV_PCM_RATE_CONTINUOUS, 402 .rate_min = 32000, 403 .rate_max = 96000, 404 .formats = WM8776_FORMATS, 405 }, 406 .ops = &wm8776_adc_ops, 407 }, 408 }; 409 410 static int wm8776_probe(struct snd_soc_codec *codec) 411 { 412 int ret = 0; 413 414 ret = wm8776_reset(codec); 415 if (ret < 0) { 416 dev_err(codec->dev, "Failed to issue reset: %d\n", ret); 417 return ret; 418 } 419 420 /* Latch the update bits; right channel only since we always 421 * update both. */ 422 snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100); 423 snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100); 424 425 return ret; 426 } 427 428 static struct snd_soc_codec_driver soc_codec_dev_wm8776 = { 429 .probe = wm8776_probe, 430 .set_bias_level = wm8776_set_bias_level, 431 .suspend_bias_off = true, 432 433 .controls = wm8776_snd_controls, 434 .num_controls = ARRAY_SIZE(wm8776_snd_controls), 435 .dapm_widgets = wm8776_dapm_widgets, 436 .num_dapm_widgets = ARRAY_SIZE(wm8776_dapm_widgets), 437 .dapm_routes = routes, 438 .num_dapm_routes = ARRAY_SIZE(routes), 439 }; 440 441 static const struct of_device_id wm8776_of_match[] = { 442 { .compatible = "wlf,wm8776", }, 443 { } 444 }; 445 MODULE_DEVICE_TABLE(of, wm8776_of_match); 446 447 static const struct regmap_config wm8776_regmap = { 448 .reg_bits = 7, 449 .val_bits = 9, 450 .max_register = WM8776_RESET, 451 452 .reg_defaults = wm8776_reg_defaults, 453 .num_reg_defaults = ARRAY_SIZE(wm8776_reg_defaults), 454 .cache_type = REGCACHE_RBTREE, 455 456 .volatile_reg = wm8776_volatile, 457 }; 458 459 #if defined(CONFIG_SPI_MASTER) 460 static int wm8776_spi_probe(struct spi_device *spi) 461 { 462 struct wm8776_priv *wm8776; 463 int ret; 464 465 wm8776 = devm_kzalloc(&spi->dev, sizeof(struct wm8776_priv), 466 GFP_KERNEL); 467 if (wm8776 == NULL) 468 return -ENOMEM; 469 470 wm8776->regmap = devm_regmap_init_spi(spi, &wm8776_regmap); 471 if (IS_ERR(wm8776->regmap)) 472 return PTR_ERR(wm8776->regmap); 473 474 spi_set_drvdata(spi, wm8776); 475 476 ret = snd_soc_register_codec(&spi->dev, 477 &soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai)); 478 479 return ret; 480 } 481 482 static int wm8776_spi_remove(struct spi_device *spi) 483 { 484 snd_soc_unregister_codec(&spi->dev); 485 return 0; 486 } 487 488 static struct spi_driver wm8776_spi_driver = { 489 .driver = { 490 .name = "wm8776", 491 .owner = THIS_MODULE, 492 .of_match_table = wm8776_of_match, 493 }, 494 .probe = wm8776_spi_probe, 495 .remove = wm8776_spi_remove, 496 }; 497 #endif /* CONFIG_SPI_MASTER */ 498 499 #if IS_ENABLED(CONFIG_I2C) 500 static int wm8776_i2c_probe(struct i2c_client *i2c, 501 const struct i2c_device_id *id) 502 { 503 struct wm8776_priv *wm8776; 504 int ret; 505 506 wm8776 = devm_kzalloc(&i2c->dev, sizeof(struct wm8776_priv), 507 GFP_KERNEL); 508 if (wm8776 == NULL) 509 return -ENOMEM; 510 511 wm8776->regmap = devm_regmap_init_i2c(i2c, &wm8776_regmap); 512 if (IS_ERR(wm8776->regmap)) 513 return PTR_ERR(wm8776->regmap); 514 515 i2c_set_clientdata(i2c, wm8776); 516 517 ret = snd_soc_register_codec(&i2c->dev, 518 &soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai)); 519 520 return ret; 521 } 522 523 static int wm8776_i2c_remove(struct i2c_client *client) 524 { 525 snd_soc_unregister_codec(&client->dev); 526 return 0; 527 } 528 529 static const struct i2c_device_id wm8776_i2c_id[] = { 530 { "wm8775", WM8775 }, 531 { "wm8776", WM8776 }, 532 { } 533 }; 534 MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id); 535 536 static struct i2c_driver wm8776_i2c_driver = { 537 .driver = { 538 .name = "wm8776", 539 .of_match_table = wm8776_of_match, 540 }, 541 .probe = wm8776_i2c_probe, 542 .remove = wm8776_i2c_remove, 543 .id_table = wm8776_i2c_id, 544 }; 545 #endif 546 547 static int __init wm8776_modinit(void) 548 { 549 int ret = 0; 550 #if IS_ENABLED(CONFIG_I2C) 551 ret = i2c_add_driver(&wm8776_i2c_driver); 552 if (ret != 0) { 553 printk(KERN_ERR "Failed to register wm8776 I2C driver: %d\n", 554 ret); 555 } 556 #endif 557 #if defined(CONFIG_SPI_MASTER) 558 ret = spi_register_driver(&wm8776_spi_driver); 559 if (ret != 0) { 560 printk(KERN_ERR "Failed to register wm8776 SPI driver: %d\n", 561 ret); 562 } 563 #endif 564 return ret; 565 } 566 module_init(wm8776_modinit); 567 568 static void __exit wm8776_exit(void) 569 { 570 #if IS_ENABLED(CONFIG_I2C) 571 i2c_del_driver(&wm8776_i2c_driver); 572 #endif 573 #if defined(CONFIG_SPI_MASTER) 574 spi_unregister_driver(&wm8776_spi_driver); 575 #endif 576 } 577 module_exit(wm8776_exit); 578 579 MODULE_DESCRIPTION("ASoC WM8776 driver"); 580 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 581 MODULE_LICENSE("GPL"); 582