1 /* 2 * wm8731.c -- WM8731 ALSA SoC Audio driver 3 * 4 * Copyright 2005 Openedhand Ltd. 5 * Copyright 2006-12 Wolfson Microelectronics, plc 6 * 7 * Author: Richard Purdie <richard@openedhand.com> 8 * 9 * Based on wm8753.c by Liam Girdwood 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/module.h> 17 #include <linux/moduleparam.h> 18 #include <linux/init.h> 19 #include <linux/delay.h> 20 #include <linux/pm.h> 21 #include <linux/i2c.h> 22 #include <linux/slab.h> 23 #include <linux/regmap.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/spi/spi.h> 26 #include <linux/of_device.h> 27 #include <linux/mutex.h> 28 #include <linux/clk.h> 29 #include <sound/core.h> 30 #include <sound/pcm.h> 31 #include <sound/pcm_params.h> 32 #include <sound/soc.h> 33 #include <sound/initval.h> 34 #include <sound/tlv.h> 35 36 #include "wm8731.h" 37 38 #define WM8731_NUM_SUPPLIES 4 39 static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = { 40 "AVDD", 41 "HPVDD", 42 "DCVDD", 43 "DBVDD", 44 }; 45 46 /* codec private data */ 47 struct wm8731_priv { 48 struct regmap *regmap; 49 struct clk *mclk; 50 struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES]; 51 const struct snd_pcm_hw_constraint_list *constraints; 52 unsigned int sysclk; 53 int sysclk_type; 54 int playback_fs; 55 bool deemph; 56 57 struct mutex lock; 58 }; 59 60 61 /* 62 * wm8731 register cache 63 */ 64 static const struct reg_default wm8731_reg_defaults[] = { 65 { 0, 0x0097 }, 66 { 1, 0x0097 }, 67 { 2, 0x0079 }, 68 { 3, 0x0079 }, 69 { 4, 0x000a }, 70 { 5, 0x0008 }, 71 { 6, 0x009f }, 72 { 7, 0x000a }, 73 { 8, 0x0000 }, 74 { 9, 0x0000 }, 75 }; 76 77 static bool wm8731_volatile(struct device *dev, unsigned int reg) 78 { 79 return reg == WM8731_RESET; 80 } 81 82 static bool wm8731_writeable(struct device *dev, unsigned int reg) 83 { 84 return reg <= WM8731_RESET; 85 } 86 87 #define wm8731_reset(m) regmap_write(m, WM8731_RESET, 0) 88 89 static const char *wm8731_input_select[] = {"Line In", "Mic"}; 90 91 static SOC_ENUM_SINGLE_DECL(wm8731_insel_enum, 92 WM8731_APANA, 2, wm8731_input_select); 93 94 static int wm8731_deemph[] = { 0, 32000, 44100, 48000 }; 95 96 static int wm8731_set_deemph(struct snd_soc_codec *codec) 97 { 98 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 99 int val, i, best; 100 101 /* If we're using deemphasis select the nearest available sample 102 * rate. 103 */ 104 if (wm8731->deemph) { 105 best = 1; 106 for (i = 2; i < ARRAY_SIZE(wm8731_deemph); i++) { 107 if (abs(wm8731_deemph[i] - wm8731->playback_fs) < 108 abs(wm8731_deemph[best] - wm8731->playback_fs)) 109 best = i; 110 } 111 112 val = best << 1; 113 } else { 114 best = 0; 115 val = 0; 116 } 117 118 dev_dbg(codec->dev, "Set deemphasis %d (%dHz)\n", 119 best, wm8731_deemph[best]); 120 121 return snd_soc_update_bits(codec, WM8731_APDIGI, 0x6, val); 122 } 123 124 static int wm8731_get_deemph(struct snd_kcontrol *kcontrol, 125 struct snd_ctl_elem_value *ucontrol) 126 { 127 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); 128 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 129 130 ucontrol->value.integer.value[0] = wm8731->deemph; 131 132 return 0; 133 } 134 135 static int wm8731_put_deemph(struct snd_kcontrol *kcontrol, 136 struct snd_ctl_elem_value *ucontrol) 137 { 138 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); 139 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 140 int deemph = ucontrol->value.integer.value[0]; 141 int ret = 0; 142 143 if (deemph > 1) 144 return -EINVAL; 145 146 mutex_lock(&wm8731->lock); 147 if (wm8731->deemph != deemph) { 148 wm8731->deemph = deemph; 149 150 wm8731_set_deemph(codec); 151 152 ret = 1; 153 } 154 mutex_unlock(&wm8731->lock); 155 156 return ret; 157 } 158 159 static const DECLARE_TLV_DB_SCALE(in_tlv, -3450, 150, 0); 160 static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -1500, 300, 0); 161 static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1); 162 static const DECLARE_TLV_DB_SCALE(mic_tlv, 0, 2000, 0); 163 164 static const struct snd_kcontrol_new wm8731_snd_controls[] = { 165 166 SOC_DOUBLE_R_TLV("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V, 167 0, 127, 0, out_tlv), 168 SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V, 169 7, 1, 0), 170 171 SOC_DOUBLE_R_TLV("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0, 172 in_tlv), 173 SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1), 174 175 SOC_SINGLE_TLV("Mic Boost Volume", WM8731_APANA, 0, 1, 0, mic_tlv), 176 SOC_SINGLE("Mic Capture Switch", WM8731_APANA, 1, 1, 1), 177 178 SOC_SINGLE_TLV("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1, 179 sidetone_tlv), 180 181 SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1), 182 SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0), 183 184 SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0, 185 wm8731_get_deemph, wm8731_put_deemph), 186 }; 187 188 /* Output Mixer */ 189 static const struct snd_kcontrol_new wm8731_output_mixer_controls[] = { 190 SOC_DAPM_SINGLE("Line Bypass Switch", WM8731_APANA, 3, 1, 0), 191 SOC_DAPM_SINGLE("Mic Sidetone Switch", WM8731_APANA, 5, 1, 0), 192 SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0), 193 }; 194 195 /* Input mux */ 196 static const struct snd_kcontrol_new wm8731_input_mux_controls = 197 SOC_DAPM_ENUM("Input Select", wm8731_insel_enum); 198 199 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = { 200 SND_SOC_DAPM_SUPPLY("ACTIVE",WM8731_ACTIVE, 0, 0, NULL, 0), 201 SND_SOC_DAPM_SUPPLY("OSC", WM8731_PWR, 5, 1, NULL, 0), 202 SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1, 203 &wm8731_output_mixer_controls[0], 204 ARRAY_SIZE(wm8731_output_mixer_controls)), 205 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8731_PWR, 3, 1), 206 SND_SOC_DAPM_OUTPUT("LOUT"), 207 SND_SOC_DAPM_OUTPUT("LHPOUT"), 208 SND_SOC_DAPM_OUTPUT("ROUT"), 209 SND_SOC_DAPM_OUTPUT("RHPOUT"), 210 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8731_PWR, 2, 1), 211 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &wm8731_input_mux_controls), 212 SND_SOC_DAPM_PGA("Line Input", WM8731_PWR, 0, 1, NULL, 0), 213 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8731_PWR, 1, 1), 214 SND_SOC_DAPM_INPUT("MICIN"), 215 SND_SOC_DAPM_INPUT("RLINEIN"), 216 SND_SOC_DAPM_INPUT("LLINEIN"), 217 }; 218 219 static int wm8731_check_osc(struct snd_soc_dapm_widget *source, 220 struct snd_soc_dapm_widget *sink) 221 { 222 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm); 223 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 224 225 return wm8731->sysclk_type == WM8731_SYSCLK_XTAL; 226 } 227 228 static const struct snd_soc_dapm_route wm8731_intercon[] = { 229 {"DAC", NULL, "OSC", wm8731_check_osc}, 230 {"ADC", NULL, "OSC", wm8731_check_osc}, 231 {"DAC", NULL, "ACTIVE"}, 232 {"ADC", NULL, "ACTIVE"}, 233 234 /* output mixer */ 235 {"Output Mixer", "Line Bypass Switch", "Line Input"}, 236 {"Output Mixer", "HiFi Playback Switch", "DAC"}, 237 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"}, 238 239 /* outputs */ 240 {"RHPOUT", NULL, "Output Mixer"}, 241 {"ROUT", NULL, "Output Mixer"}, 242 {"LHPOUT", NULL, "Output Mixer"}, 243 {"LOUT", NULL, "Output Mixer"}, 244 245 /* input mux */ 246 {"Input Mux", "Line In", "Line Input"}, 247 {"Input Mux", "Mic", "Mic Bias"}, 248 {"ADC", NULL, "Input Mux"}, 249 250 /* inputs */ 251 {"Line Input", NULL, "LLINEIN"}, 252 {"Line Input", NULL, "RLINEIN"}, 253 {"Mic Bias", NULL, "MICIN"}, 254 }; 255 256 struct _coeff_div { 257 u32 mclk; 258 u32 rate; 259 u16 fs; 260 u8 sr:4; 261 u8 bosr:1; 262 u8 usb:1; 263 }; 264 265 /* codec mclk clock divider coefficients */ 266 static const struct _coeff_div coeff_div[] = { 267 /* 48k */ 268 {12288000, 48000, 256, 0x0, 0x0, 0x0}, 269 {18432000, 48000, 384, 0x0, 0x1, 0x0}, 270 {12000000, 48000, 250, 0x0, 0x0, 0x1}, 271 272 /* 32k */ 273 {12288000, 32000, 384, 0x6, 0x0, 0x0}, 274 {18432000, 32000, 576, 0x6, 0x1, 0x0}, 275 {12000000, 32000, 375, 0x6, 0x0, 0x1}, 276 277 /* 8k */ 278 {12288000, 8000, 1536, 0x3, 0x0, 0x0}, 279 {18432000, 8000, 2304, 0x3, 0x1, 0x0}, 280 {11289600, 8000, 1408, 0xb, 0x0, 0x0}, 281 {16934400, 8000, 2112, 0xb, 0x1, 0x0}, 282 {12000000, 8000, 1500, 0x3, 0x0, 0x1}, 283 284 /* 96k */ 285 {12288000, 96000, 128, 0x7, 0x0, 0x0}, 286 {18432000, 96000, 192, 0x7, 0x1, 0x0}, 287 {12000000, 96000, 125, 0x7, 0x0, 0x1}, 288 289 /* 44.1k */ 290 {11289600, 44100, 256, 0x8, 0x0, 0x0}, 291 {16934400, 44100, 384, 0x8, 0x1, 0x0}, 292 {12000000, 44100, 272, 0x8, 0x1, 0x1}, 293 294 /* 88.2k */ 295 {11289600, 88200, 128, 0xf, 0x0, 0x0}, 296 {16934400, 88200, 192, 0xf, 0x1, 0x0}, 297 {12000000, 88200, 136, 0xf, 0x1, 0x1}, 298 }; 299 300 /* rates constraints */ 301 static const unsigned int wm8731_rates_12000000[] = { 302 8000, 32000, 44100, 48000, 96000, 88200, 303 }; 304 305 static const unsigned int wm8731_rates_12288000_18432000[] = { 306 8000, 32000, 48000, 96000, 307 }; 308 309 static const unsigned int wm8731_rates_11289600_16934400[] = { 310 8000, 44100, 88200, 311 }; 312 313 static const struct snd_pcm_hw_constraint_list wm8731_constraints_12000000 = { 314 .list = wm8731_rates_12000000, 315 .count = ARRAY_SIZE(wm8731_rates_12000000), 316 }; 317 318 static const 319 struct snd_pcm_hw_constraint_list wm8731_constraints_12288000_18432000 = { 320 .list = wm8731_rates_12288000_18432000, 321 .count = ARRAY_SIZE(wm8731_rates_12288000_18432000), 322 }; 323 324 static const 325 struct snd_pcm_hw_constraint_list wm8731_constraints_11289600_16934400 = { 326 .list = wm8731_rates_11289600_16934400, 327 .count = ARRAY_SIZE(wm8731_rates_11289600_16934400), 328 }; 329 330 static inline int get_coeff(int mclk, int rate) 331 { 332 int i; 333 334 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { 335 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) 336 return i; 337 } 338 return 0; 339 } 340 341 static int wm8731_hw_params(struct snd_pcm_substream *substream, 342 struct snd_pcm_hw_params *params, 343 struct snd_soc_dai *dai) 344 { 345 struct snd_soc_codec *codec = dai->codec; 346 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 347 u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3; 348 int i = get_coeff(wm8731->sysclk, params_rate(params)); 349 u16 srate = (coeff_div[i].sr << 2) | 350 (coeff_div[i].bosr << 1) | coeff_div[i].usb; 351 352 wm8731->playback_fs = params_rate(params); 353 354 snd_soc_write(codec, WM8731_SRATE, srate); 355 356 /* bit size */ 357 switch (params_width(params)) { 358 case 16: 359 break; 360 case 20: 361 iface |= 0x0004; 362 break; 363 case 24: 364 iface |= 0x0008; 365 break; 366 } 367 368 wm8731_set_deemph(codec); 369 370 snd_soc_write(codec, WM8731_IFACE, iface); 371 return 0; 372 } 373 374 static int wm8731_mute(struct snd_soc_dai *dai, int mute) 375 { 376 struct snd_soc_codec *codec = dai->codec; 377 u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7; 378 379 if (mute) 380 snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8); 381 else 382 snd_soc_write(codec, WM8731_APDIGI, mute_reg); 383 return 0; 384 } 385 386 static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai, 387 int clk_id, unsigned int freq, int dir) 388 { 389 struct snd_soc_codec *codec = codec_dai->codec; 390 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); 391 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 392 393 switch (clk_id) { 394 case WM8731_SYSCLK_XTAL: 395 case WM8731_SYSCLK_MCLK: 396 if (wm8731->mclk && clk_set_rate(wm8731->mclk, freq)) 397 return -EINVAL; 398 wm8731->sysclk_type = clk_id; 399 break; 400 default: 401 return -EINVAL; 402 } 403 404 switch (freq) { 405 case 0: 406 wm8731->constraints = NULL; 407 break; 408 case 12000000: 409 wm8731->constraints = &wm8731_constraints_12000000; 410 break; 411 case 12288000: 412 case 18432000: 413 wm8731->constraints = &wm8731_constraints_12288000_18432000; 414 break; 415 case 16934400: 416 case 11289600: 417 wm8731->constraints = &wm8731_constraints_11289600_16934400; 418 break; 419 default: 420 return -EINVAL; 421 } 422 423 wm8731->sysclk = freq; 424 425 snd_soc_dapm_sync(dapm); 426 427 return 0; 428 } 429 430 431 static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai, 432 unsigned int fmt) 433 { 434 struct snd_soc_codec *codec = codec_dai->codec; 435 u16 iface = 0; 436 437 /* set master/slave audio interface */ 438 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 439 case SND_SOC_DAIFMT_CBM_CFM: 440 iface |= 0x0040; 441 break; 442 case SND_SOC_DAIFMT_CBS_CFS: 443 break; 444 default: 445 return -EINVAL; 446 } 447 448 /* interface format */ 449 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 450 case SND_SOC_DAIFMT_I2S: 451 iface |= 0x0002; 452 break; 453 case SND_SOC_DAIFMT_RIGHT_J: 454 break; 455 case SND_SOC_DAIFMT_LEFT_J: 456 iface |= 0x0001; 457 break; 458 case SND_SOC_DAIFMT_DSP_A: 459 iface |= 0x0013; 460 break; 461 case SND_SOC_DAIFMT_DSP_B: 462 iface |= 0x0003; 463 break; 464 default: 465 return -EINVAL; 466 } 467 468 /* clock inversion */ 469 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 470 case SND_SOC_DAIFMT_NB_NF: 471 break; 472 case SND_SOC_DAIFMT_IB_IF: 473 iface |= 0x0090; 474 break; 475 case SND_SOC_DAIFMT_IB_NF: 476 iface |= 0x0080; 477 break; 478 case SND_SOC_DAIFMT_NB_IF: 479 iface |= 0x0010; 480 break; 481 default: 482 return -EINVAL; 483 } 484 485 /* set iface */ 486 snd_soc_write(codec, WM8731_IFACE, iface); 487 return 0; 488 } 489 490 static int wm8731_set_bias_level(struct snd_soc_codec *codec, 491 enum snd_soc_bias_level level) 492 { 493 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 494 int ret; 495 u16 reg; 496 497 switch (level) { 498 case SND_SOC_BIAS_ON: 499 if (wm8731->mclk) { 500 ret = clk_prepare_enable(wm8731->mclk); 501 if (ret) 502 return ret; 503 } 504 break; 505 case SND_SOC_BIAS_PREPARE: 506 break; 507 case SND_SOC_BIAS_STANDBY: 508 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { 509 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), 510 wm8731->supplies); 511 if (ret != 0) 512 return ret; 513 514 regcache_sync(wm8731->regmap); 515 } 516 517 /* Clear PWROFF, gate CLKOUT, everything else as-is */ 518 reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f; 519 snd_soc_write(codec, WM8731_PWR, reg | 0x0040); 520 break; 521 case SND_SOC_BIAS_OFF: 522 if (wm8731->mclk) 523 clk_disable_unprepare(wm8731->mclk); 524 snd_soc_write(codec, WM8731_PWR, 0xffff); 525 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), 526 wm8731->supplies); 527 regcache_mark_dirty(wm8731->regmap); 528 break; 529 } 530 return 0; 531 } 532 533 static int wm8731_startup(struct snd_pcm_substream *substream, 534 struct snd_soc_dai *dai) 535 { 536 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(dai->codec); 537 538 if (wm8731->constraints) 539 snd_pcm_hw_constraint_list(substream->runtime, 0, 540 SNDRV_PCM_HW_PARAM_RATE, 541 wm8731->constraints); 542 543 return 0; 544 } 545 546 #define WM8731_RATES SNDRV_PCM_RATE_8000_96000 547 548 #define WM8731_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 549 SNDRV_PCM_FMTBIT_S24_LE) 550 551 static const struct snd_soc_dai_ops wm8731_dai_ops = { 552 .startup = wm8731_startup, 553 .hw_params = wm8731_hw_params, 554 .digital_mute = wm8731_mute, 555 .set_sysclk = wm8731_set_dai_sysclk, 556 .set_fmt = wm8731_set_dai_fmt, 557 }; 558 559 static struct snd_soc_dai_driver wm8731_dai = { 560 .name = "wm8731-hifi", 561 .playback = { 562 .stream_name = "Playback", 563 .channels_min = 1, 564 .channels_max = 2, 565 .rates = WM8731_RATES, 566 .formats = WM8731_FORMATS,}, 567 .capture = { 568 .stream_name = "Capture", 569 .channels_min = 1, 570 .channels_max = 2, 571 .rates = WM8731_RATES, 572 .formats = WM8731_FORMATS,}, 573 .ops = &wm8731_dai_ops, 574 .symmetric_rates = 1, 575 }; 576 577 static int wm8731_request_supplies(struct device *dev, 578 struct wm8731_priv *wm8731) 579 { 580 int ret = 0, i; 581 582 for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++) 583 wm8731->supplies[i].supply = wm8731_supply_names[i]; 584 585 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(wm8731->supplies), 586 wm8731->supplies); 587 if (ret != 0) { 588 dev_err(dev, "Failed to request supplies: %d\n", ret); 589 return ret; 590 } 591 592 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), 593 wm8731->supplies); 594 if (ret != 0) { 595 dev_err(dev, "Failed to enable supplies: %d\n", ret); 596 return ret; 597 } 598 599 return 0; 600 } 601 602 static int wm8731_hw_init(struct device *dev, struct wm8731_priv *wm8731) 603 { 604 int ret = 0; 605 606 ret = wm8731_reset(wm8731->regmap); 607 if (ret < 0) { 608 dev_err(dev, "Failed to issue reset: %d\n", ret); 609 goto err_regulator_enable; 610 } 611 612 /* Clear POWEROFF, keep everything else disabled */ 613 regmap_write(wm8731->regmap, WM8731_PWR, 0x7f); 614 615 /* Latch the update bits */ 616 regmap_update_bits(wm8731->regmap, WM8731_LOUT1V, 0x100, 0); 617 regmap_update_bits(wm8731->regmap, WM8731_ROUT1V, 0x100, 0); 618 regmap_update_bits(wm8731->regmap, WM8731_LINVOL, 0x100, 0); 619 regmap_update_bits(wm8731->regmap, WM8731_RINVOL, 0x100, 0); 620 621 /* Disable bypass path by default */ 622 regmap_update_bits(wm8731->regmap, WM8731_APANA, 0x8, 0); 623 624 regcache_mark_dirty(wm8731->regmap); 625 626 err_regulator_enable: 627 /* Regulators will be enabled by bias management */ 628 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 629 630 return ret; 631 } 632 633 static struct snd_soc_codec_driver soc_codec_dev_wm8731 = { 634 .set_bias_level = wm8731_set_bias_level, 635 .suspend_bias_off = true, 636 637 .dapm_widgets = wm8731_dapm_widgets, 638 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets), 639 .dapm_routes = wm8731_intercon, 640 .num_dapm_routes = ARRAY_SIZE(wm8731_intercon), 641 .controls = wm8731_snd_controls, 642 .num_controls = ARRAY_SIZE(wm8731_snd_controls), 643 }; 644 645 static const struct of_device_id wm8731_of_match[] = { 646 { .compatible = "wlf,wm8731", }, 647 { } 648 }; 649 650 MODULE_DEVICE_TABLE(of, wm8731_of_match); 651 652 static const struct regmap_config wm8731_regmap = { 653 .reg_bits = 7, 654 .val_bits = 9, 655 656 .max_register = WM8731_RESET, 657 .volatile_reg = wm8731_volatile, 658 .writeable_reg = wm8731_writeable, 659 660 .cache_type = REGCACHE_RBTREE, 661 .reg_defaults = wm8731_reg_defaults, 662 .num_reg_defaults = ARRAY_SIZE(wm8731_reg_defaults), 663 }; 664 665 #if defined(CONFIG_SPI_MASTER) 666 static int wm8731_spi_probe(struct spi_device *spi) 667 { 668 struct wm8731_priv *wm8731; 669 int ret; 670 671 wm8731 = devm_kzalloc(&spi->dev, sizeof(*wm8731), GFP_KERNEL); 672 if (wm8731 == NULL) 673 return -ENOMEM; 674 675 wm8731->mclk = devm_clk_get(&spi->dev, "mclk"); 676 if (IS_ERR(wm8731->mclk)) { 677 ret = PTR_ERR(wm8731->mclk); 678 if (ret == -ENOENT) { 679 wm8731->mclk = NULL; 680 dev_warn(&spi->dev, "Assuming static MCLK\n"); 681 } else { 682 dev_err(&spi->dev, "Failed to get MCLK: %d\n", 683 ret); 684 return ret; 685 } 686 } 687 688 mutex_init(&wm8731->lock); 689 690 spi_set_drvdata(spi, wm8731); 691 692 ret = wm8731_request_supplies(&spi->dev, wm8731); 693 if (ret != 0) 694 return ret; 695 696 wm8731->regmap = devm_regmap_init_spi(spi, &wm8731_regmap); 697 if (IS_ERR(wm8731->regmap)) { 698 ret = PTR_ERR(wm8731->regmap); 699 dev_err(&spi->dev, "Failed to allocate register map: %d\n", 700 ret); 701 return ret; 702 } 703 704 ret = wm8731_hw_init(&spi->dev, wm8731); 705 if (ret != 0) 706 return ret; 707 708 ret = snd_soc_register_codec(&spi->dev, 709 &soc_codec_dev_wm8731, &wm8731_dai, 1); 710 if (ret != 0) { 711 dev_err(&spi->dev, "Failed to register CODEC: %d\n", ret); 712 return ret; 713 } 714 715 return 0; 716 } 717 718 static int wm8731_spi_remove(struct spi_device *spi) 719 { 720 snd_soc_unregister_codec(&spi->dev); 721 return 0; 722 } 723 724 static struct spi_driver wm8731_spi_driver = { 725 .driver = { 726 .name = "wm8731", 727 .owner = THIS_MODULE, 728 .of_match_table = wm8731_of_match, 729 }, 730 .probe = wm8731_spi_probe, 731 .remove = wm8731_spi_remove, 732 }; 733 #endif /* CONFIG_SPI_MASTER */ 734 735 #if IS_ENABLED(CONFIG_I2C) 736 static int wm8731_i2c_probe(struct i2c_client *i2c, 737 const struct i2c_device_id *id) 738 { 739 struct wm8731_priv *wm8731; 740 int ret; 741 742 wm8731 = devm_kzalloc(&i2c->dev, sizeof(struct wm8731_priv), 743 GFP_KERNEL); 744 if (wm8731 == NULL) 745 return -ENOMEM; 746 747 wm8731->mclk = devm_clk_get(&i2c->dev, "mclk"); 748 if (IS_ERR(wm8731->mclk)) { 749 ret = PTR_ERR(wm8731->mclk); 750 if (ret == -ENOENT) { 751 wm8731->mclk = NULL; 752 dev_warn(&i2c->dev, "Assuming static MCLK\n"); 753 } else { 754 dev_err(&i2c->dev, "Failed to get MCLK: %d\n", 755 ret); 756 return ret; 757 } 758 } 759 760 mutex_init(&wm8731->lock); 761 762 i2c_set_clientdata(i2c, wm8731); 763 764 ret = wm8731_request_supplies(&i2c->dev, wm8731); 765 if (ret != 0) 766 return ret; 767 768 wm8731->regmap = devm_regmap_init_i2c(i2c, &wm8731_regmap); 769 if (IS_ERR(wm8731->regmap)) { 770 ret = PTR_ERR(wm8731->regmap); 771 dev_err(&i2c->dev, "Failed to allocate register map: %d\n", 772 ret); 773 return ret; 774 } 775 776 ret = wm8731_hw_init(&i2c->dev, wm8731); 777 if (ret != 0) 778 return ret; 779 780 ret = snd_soc_register_codec(&i2c->dev, 781 &soc_codec_dev_wm8731, &wm8731_dai, 1); 782 if (ret != 0) { 783 dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); 784 return ret; 785 } 786 787 return 0; 788 } 789 790 static int wm8731_i2c_remove(struct i2c_client *client) 791 { 792 snd_soc_unregister_codec(&client->dev); 793 return 0; 794 } 795 796 static const struct i2c_device_id wm8731_i2c_id[] = { 797 { "wm8731", 0 }, 798 { } 799 }; 800 MODULE_DEVICE_TABLE(i2c, wm8731_i2c_id); 801 802 static struct i2c_driver wm8731_i2c_driver = { 803 .driver = { 804 .name = "wm8731", 805 .owner = THIS_MODULE, 806 .of_match_table = wm8731_of_match, 807 }, 808 .probe = wm8731_i2c_probe, 809 .remove = wm8731_i2c_remove, 810 .id_table = wm8731_i2c_id, 811 }; 812 #endif 813 814 static int __init wm8731_modinit(void) 815 { 816 int ret = 0; 817 #if IS_ENABLED(CONFIG_I2C) 818 ret = i2c_add_driver(&wm8731_i2c_driver); 819 if (ret != 0) { 820 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n", 821 ret); 822 } 823 #endif 824 #if defined(CONFIG_SPI_MASTER) 825 ret = spi_register_driver(&wm8731_spi_driver); 826 if (ret != 0) { 827 printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n", 828 ret); 829 } 830 #endif 831 return ret; 832 } 833 module_init(wm8731_modinit); 834 835 static void __exit wm8731_exit(void) 836 { 837 #if IS_ENABLED(CONFIG_I2C) 838 i2c_del_driver(&wm8731_i2c_driver); 839 #endif 840 #if defined(CONFIG_SPI_MASTER) 841 spi_unregister_driver(&wm8731_spi_driver); 842 #endif 843 } 844 module_exit(wm8731_exit); 845 846 MODULE_DESCRIPTION("ASoC WM8731 driver"); 847 MODULE_AUTHOR("Richard Purdie"); 848 MODULE_LICENSE("GPL"); 849