1 /* 2 * wm8741.c -- WM8741 ALSA SoC Audio driver 3 * 4 * Copyright 2010 Wolfson Microelectronics plc 5 * 6 * Author: Ian Lartey <ian@opensource.wolfsonmicro.com> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/init.h> 17 #include <linux/delay.h> 18 #include <linux/pm.h> 19 #include <linux/i2c.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/consumer.h> 22 #include <linux/slab.h> 23 #include <sound/core.h> 24 #include <sound/pcm.h> 25 #include <sound/pcm_params.h> 26 #include <sound/soc.h> 27 #include <sound/initval.h> 28 #include <sound/tlv.h> 29 30 #include "wm8741.h" 31 32 #define WM8741_NUM_SUPPLIES 2 33 static const char *wm8741_supply_names[WM8741_NUM_SUPPLIES] = { 34 "AVDD", 35 "DVDD", 36 }; 37 38 #define WM8741_NUM_RATES 6 39 40 /* codec private data */ 41 struct wm8741_priv { 42 enum snd_soc_control_type control_type; 43 struct regulator_bulk_data supplies[WM8741_NUM_SUPPLIES]; 44 unsigned int sysclk; 45 struct snd_pcm_hw_constraint_list *sysclk_constraints; 46 }; 47 48 static const u16 wm8741_reg_defaults[WM8741_REGISTER_COUNT] = { 49 0x0000, /* R0 - DACLLSB Attenuation */ 50 0x0000, /* R1 - DACLMSB Attenuation */ 51 0x0000, /* R2 - DACRLSB Attenuation */ 52 0x0000, /* R3 - DACRMSB Attenuation */ 53 0x0000, /* R4 - Volume Control */ 54 0x000A, /* R5 - Format Control */ 55 0x0000, /* R6 - Filter Control */ 56 0x0000, /* R7 - Mode Control 1 */ 57 0x0002, /* R8 - Mode Control 2 */ 58 0x0000, /* R9 - Reset */ 59 0x0002, /* R32 - ADDITONAL_CONTROL_1 */ 60 }; 61 62 63 static int wm8741_reset(struct snd_soc_codec *codec) 64 { 65 return snd_soc_write(codec, WM8741_RESET, 0); 66 } 67 68 static const DECLARE_TLV_DB_SCALE(dac_tlv_fine, -12700, 13, 0); 69 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 400, 0); 70 71 static const struct snd_kcontrol_new wm8741_snd_controls[] = { 72 SOC_DOUBLE_R_TLV("Fine Playback Volume", WM8741_DACLLSB_ATTENUATION, 73 WM8741_DACRLSB_ATTENUATION, 1, 255, 1, dac_tlv_fine), 74 SOC_DOUBLE_R_TLV("Playback Volume", WM8741_DACLMSB_ATTENUATION, 75 WM8741_DACRMSB_ATTENUATION, 0, 511, 1, dac_tlv), 76 }; 77 78 static const struct snd_soc_dapm_widget wm8741_dapm_widgets[] = { 79 SND_SOC_DAPM_DAC("DACL", "Playback", SND_SOC_NOPM, 0, 0), 80 SND_SOC_DAPM_DAC("DACR", "Playback", SND_SOC_NOPM, 0, 0), 81 SND_SOC_DAPM_OUTPUT("VOUTLP"), 82 SND_SOC_DAPM_OUTPUT("VOUTLN"), 83 SND_SOC_DAPM_OUTPUT("VOUTRP"), 84 SND_SOC_DAPM_OUTPUT("VOUTRN"), 85 }; 86 87 static const struct snd_soc_dapm_route intercon[] = { 88 { "VOUTLP", NULL, "DACL" }, 89 { "VOUTLN", NULL, "DACL" }, 90 { "VOUTRP", NULL, "DACR" }, 91 { "VOUTRN", NULL, "DACR" }, 92 }; 93 94 static int wm8741_add_widgets(struct snd_soc_codec *codec) 95 { 96 struct snd_soc_dapm_context *dapm = &codec->dapm; 97 98 snd_soc_dapm_new_controls(dapm, wm8741_dapm_widgets, 99 ARRAY_SIZE(wm8741_dapm_widgets)); 100 snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon)); 101 102 return 0; 103 } 104 105 static struct { 106 int value; 107 int ratio; 108 } lrclk_ratios[WM8741_NUM_RATES] = { 109 { 1, 128 }, 110 { 2, 192 }, 111 { 3, 256 }, 112 { 4, 384 }, 113 { 5, 512 }, 114 { 6, 768 }, 115 }; 116 117 static unsigned int rates_11289[] = { 118 44100, 88235, 119 }; 120 121 static struct snd_pcm_hw_constraint_list constraints_11289 = { 122 .count = ARRAY_SIZE(rates_11289), 123 .list = rates_11289, 124 }; 125 126 static unsigned int rates_12288[] = { 127 32000, 48000, 96000, 128 }; 129 130 static struct snd_pcm_hw_constraint_list constraints_12288 = { 131 .count = ARRAY_SIZE(rates_12288), 132 .list = rates_12288, 133 }; 134 135 static unsigned int rates_16384[] = { 136 32000, 137 }; 138 139 static struct snd_pcm_hw_constraint_list constraints_16384 = { 140 .count = ARRAY_SIZE(rates_16384), 141 .list = rates_16384, 142 }; 143 144 static unsigned int rates_16934[] = { 145 44100, 88235, 146 }; 147 148 static struct snd_pcm_hw_constraint_list constraints_16934 = { 149 .count = ARRAY_SIZE(rates_16934), 150 .list = rates_16934, 151 }; 152 153 static unsigned int rates_18432[] = { 154 48000, 96000, 155 }; 156 157 static struct snd_pcm_hw_constraint_list constraints_18432 = { 158 .count = ARRAY_SIZE(rates_18432), 159 .list = rates_18432, 160 }; 161 162 static unsigned int rates_22579[] = { 163 44100, 88235, 1764000 164 }; 165 166 static struct snd_pcm_hw_constraint_list constraints_22579 = { 167 .count = ARRAY_SIZE(rates_22579), 168 .list = rates_22579, 169 }; 170 171 static unsigned int rates_24576[] = { 172 32000, 48000, 96000, 192000 173 }; 174 175 static struct snd_pcm_hw_constraint_list constraints_24576 = { 176 .count = ARRAY_SIZE(rates_24576), 177 .list = rates_24576, 178 }; 179 180 static unsigned int rates_36864[] = { 181 48000, 96000, 19200 182 }; 183 184 static struct snd_pcm_hw_constraint_list constraints_36864 = { 185 .count = ARRAY_SIZE(rates_36864), 186 .list = rates_36864, 187 }; 188 189 190 static int wm8741_startup(struct snd_pcm_substream *substream, 191 struct snd_soc_dai *dai) 192 { 193 struct snd_soc_codec *codec = dai->codec; 194 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec); 195 196 /* The set of sample rates that can be supported depends on the 197 * MCLK supplied to the CODEC - enforce this. 198 */ 199 if (!wm8741->sysclk) { 200 dev_err(codec->dev, 201 "No MCLK configured, call set_sysclk() on init\n"); 202 return -EINVAL; 203 } 204 205 snd_pcm_hw_constraint_list(substream->runtime, 0, 206 SNDRV_PCM_HW_PARAM_RATE, 207 wm8741->sysclk_constraints); 208 209 return 0; 210 } 211 212 static int wm8741_hw_params(struct snd_pcm_substream *substream, 213 struct snd_pcm_hw_params *params, 214 struct snd_soc_dai *dai) 215 { 216 struct snd_soc_pcm_runtime *rtd = substream->private_data; 217 struct snd_soc_codec *codec = rtd->codec; 218 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec); 219 u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1FC; 220 int i; 221 222 /* Find a supported LRCLK ratio */ 223 for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) { 224 if (wm8741->sysclk / params_rate(params) == 225 lrclk_ratios[i].ratio) 226 break; 227 } 228 229 /* Should never happen, should be handled by constraints */ 230 if (i == ARRAY_SIZE(lrclk_ratios)) { 231 dev_err(codec->dev, "MCLK/fs ratio %d unsupported\n", 232 wm8741->sysclk / params_rate(params)); 233 return -EINVAL; 234 } 235 236 /* bit size */ 237 switch (params_format(params)) { 238 case SNDRV_PCM_FORMAT_S16_LE: 239 break; 240 case SNDRV_PCM_FORMAT_S20_3LE: 241 iface |= 0x0001; 242 break; 243 case SNDRV_PCM_FORMAT_S24_LE: 244 iface |= 0x0002; 245 break; 246 case SNDRV_PCM_FORMAT_S32_LE: 247 iface |= 0x0003; 248 break; 249 default: 250 dev_dbg(codec->dev, "wm8741_hw_params: Unsupported bit size param = %d", 251 params_format(params)); 252 return -EINVAL; 253 } 254 255 dev_dbg(codec->dev, "wm8741_hw_params: bit size param = %d", 256 params_format(params)); 257 258 snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface); 259 return 0; 260 } 261 262 static int wm8741_set_dai_sysclk(struct snd_soc_dai *codec_dai, 263 int clk_id, unsigned int freq, int dir) 264 { 265 struct snd_soc_codec *codec = codec_dai->codec; 266 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec); 267 268 dev_dbg(codec->dev, "wm8741_set_dai_sysclk info: freq=%dHz\n", freq); 269 270 switch (freq) { 271 case 11289600: 272 wm8741->sysclk_constraints = &constraints_11289; 273 wm8741->sysclk = freq; 274 return 0; 275 276 case 12288000: 277 wm8741->sysclk_constraints = &constraints_12288; 278 wm8741->sysclk = freq; 279 return 0; 280 281 case 16384000: 282 wm8741->sysclk_constraints = &constraints_16384; 283 wm8741->sysclk = freq; 284 return 0; 285 286 case 16934400: 287 wm8741->sysclk_constraints = &constraints_16934; 288 wm8741->sysclk = freq; 289 return 0; 290 291 case 18432000: 292 wm8741->sysclk_constraints = &constraints_18432; 293 wm8741->sysclk = freq; 294 return 0; 295 296 case 22579200: 297 case 33868800: 298 wm8741->sysclk_constraints = &constraints_22579; 299 wm8741->sysclk = freq; 300 return 0; 301 302 case 24576000: 303 wm8741->sysclk_constraints = &constraints_24576; 304 wm8741->sysclk = freq; 305 return 0; 306 307 case 36864000: 308 wm8741->sysclk_constraints = &constraints_36864; 309 wm8741->sysclk = freq; 310 return 0; 311 } 312 return -EINVAL; 313 } 314 315 static int wm8741_set_dai_fmt(struct snd_soc_dai *codec_dai, 316 unsigned int fmt) 317 { 318 struct snd_soc_codec *codec = codec_dai->codec; 319 u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1C3; 320 321 /* check master/slave audio interface */ 322 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 323 case SND_SOC_DAIFMT_CBS_CFS: 324 break; 325 default: 326 return -EINVAL; 327 } 328 329 /* interface format */ 330 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 331 case SND_SOC_DAIFMT_I2S: 332 iface |= 0x0008; 333 break; 334 case SND_SOC_DAIFMT_RIGHT_J: 335 break; 336 case SND_SOC_DAIFMT_LEFT_J: 337 iface |= 0x0004; 338 break; 339 case SND_SOC_DAIFMT_DSP_A: 340 iface |= 0x0003; 341 break; 342 case SND_SOC_DAIFMT_DSP_B: 343 iface |= 0x0013; 344 break; 345 default: 346 return -EINVAL; 347 } 348 349 /* clock inversion */ 350 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 351 case SND_SOC_DAIFMT_NB_NF: 352 break; 353 case SND_SOC_DAIFMT_IB_IF: 354 iface |= 0x0010; 355 break; 356 case SND_SOC_DAIFMT_IB_NF: 357 iface |= 0x0020; 358 break; 359 case SND_SOC_DAIFMT_NB_IF: 360 iface |= 0x0030; 361 break; 362 default: 363 return -EINVAL; 364 } 365 366 367 dev_dbg(codec->dev, "wm8741_set_dai_fmt: Format=%x, Clock Inv=%x\n", 368 fmt & SND_SOC_DAIFMT_FORMAT_MASK, 369 ((fmt & SND_SOC_DAIFMT_INV_MASK))); 370 371 snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface); 372 return 0; 373 } 374 375 #define WM8741_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \ 376 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \ 377 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 | \ 378 SNDRV_PCM_RATE_192000) 379 380 #define WM8741_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 381 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE) 382 383 static struct snd_soc_dai_ops wm8741_dai_ops = { 384 .startup = wm8741_startup, 385 .hw_params = wm8741_hw_params, 386 .set_sysclk = wm8741_set_dai_sysclk, 387 .set_fmt = wm8741_set_dai_fmt, 388 }; 389 390 static struct snd_soc_dai_driver wm8741_dai = { 391 .name = "wm8741", 392 .playback = { 393 .stream_name = "Playback", 394 .channels_min = 2, /* Mono modes not yet supported */ 395 .channels_max = 2, 396 .rates = WM8741_RATES, 397 .formats = WM8741_FORMATS, 398 }, 399 .ops = &wm8741_dai_ops, 400 }; 401 402 #ifdef CONFIG_PM 403 static int wm8741_resume(struct snd_soc_codec *codec) 404 { 405 u16 *cache = codec->reg_cache; 406 int i; 407 408 /* RESTORE REG Cache */ 409 for (i = 0; i < WM8741_REGISTER_COUNT; i++) { 410 if (cache[i] == wm8741_reg_defaults[i] || WM8741_RESET == i) 411 continue; 412 snd_soc_write(codec, i, cache[i]); 413 } 414 return 0; 415 } 416 #else 417 #define wm8741_suspend NULL 418 #define wm8741_resume NULL 419 #endif 420 421 static int wm8741_probe(struct snd_soc_codec *codec) 422 { 423 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec); 424 u16 *reg_cache = codec->reg_cache; 425 int ret = 0; 426 427 ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8741->control_type); 428 if (ret != 0) { 429 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); 430 return ret; 431 } 432 433 ret = wm8741_reset(codec); 434 if (ret < 0) { 435 dev_err(codec->dev, "Failed to issue reset\n"); 436 return ret; 437 } 438 439 /* Change some default settings - latch VU */ 440 reg_cache[WM8741_DACLLSB_ATTENUATION] |= WM8741_UPDATELL; 441 reg_cache[WM8741_DACLMSB_ATTENUATION] |= WM8741_UPDATELM; 442 reg_cache[WM8741_DACRLSB_ATTENUATION] |= WM8741_UPDATERL; 443 reg_cache[WM8741_DACRLSB_ATTENUATION] |= WM8741_UPDATERM; 444 445 snd_soc_add_controls(codec, wm8741_snd_controls, 446 ARRAY_SIZE(wm8741_snd_controls)); 447 wm8741_add_widgets(codec); 448 449 dev_dbg(codec->dev, "Successful registration\n"); 450 return ret; 451 } 452 453 static struct snd_soc_codec_driver soc_codec_dev_wm8741 = { 454 .probe = wm8741_probe, 455 .resume = wm8741_resume, 456 .reg_cache_size = ARRAY_SIZE(wm8741_reg_defaults), 457 .reg_word_size = sizeof(u16), 458 .reg_cache_default = wm8741_reg_defaults, 459 }; 460 461 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 462 static int wm8741_i2c_probe(struct i2c_client *i2c, 463 const struct i2c_device_id *id) 464 { 465 struct wm8741_priv *wm8741; 466 int ret, i; 467 468 wm8741 = kzalloc(sizeof(struct wm8741_priv), GFP_KERNEL); 469 if (wm8741 == NULL) 470 return -ENOMEM; 471 472 for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++) 473 wm8741->supplies[i].supply = wm8741_supply_names[i]; 474 475 ret = regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies), 476 wm8741->supplies); 477 if (ret != 0) { 478 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret); 479 goto err; 480 } 481 482 ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies), 483 wm8741->supplies); 484 if (ret != 0) { 485 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret); 486 goto err_get; 487 } 488 489 i2c_set_clientdata(i2c, wm8741); 490 wm8741->control_type = SND_SOC_I2C; 491 492 ret = snd_soc_register_codec(&i2c->dev, 493 &soc_codec_dev_wm8741, &wm8741_dai, 1); 494 if (ret < 0) 495 goto err_enable; 496 return ret; 497 498 err_enable: 499 regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); 500 501 err_get: 502 regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); 503 err: 504 kfree(wm8741); 505 return ret; 506 } 507 508 static int wm8741_i2c_remove(struct i2c_client *client) 509 { 510 struct wm8741_priv *wm8741 = i2c_get_clientdata(client); 511 512 snd_soc_unregister_codec(&client->dev); 513 regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); 514 kfree(i2c_get_clientdata(client)); 515 return 0; 516 } 517 518 static const struct i2c_device_id wm8741_i2c_id[] = { 519 { "wm8741", 0 }, 520 { } 521 }; 522 MODULE_DEVICE_TABLE(i2c, wm8741_i2c_id); 523 524 static struct i2c_driver wm8741_i2c_driver = { 525 .driver = { 526 .name = "wm8741-codec", 527 .owner = THIS_MODULE, 528 }, 529 .probe = wm8741_i2c_probe, 530 .remove = wm8741_i2c_remove, 531 .id_table = wm8741_i2c_id, 532 }; 533 #endif 534 535 static int __init wm8741_modinit(void) 536 { 537 int ret = 0; 538 539 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 540 ret = i2c_add_driver(&wm8741_i2c_driver); 541 if (ret != 0) 542 pr_err("Failed to register WM8741 I2C driver: %d\n", ret); 543 #endif 544 545 return ret; 546 } 547 module_init(wm8741_modinit); 548 549 static void __exit wm8741_exit(void) 550 { 551 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 552 i2c_del_driver(&wm8741_i2c_driver); 553 #endif 554 } 555 module_exit(wm8741_exit); 556 557 MODULE_DESCRIPTION("ASoC WM8741 driver"); 558 MODULE_AUTHOR("Ian Lartey <ian@opensource.wolfsonmicro.com>"); 559 MODULE_LICENSE("GPL"); 560