1 /* 2 * wm8731.c -- WM8731 ALSA SoC Audio driver 3 * 4 * Copyright 2005 Openedhand Ltd. 5 * 6 * Author: Richard Purdie <richard@openedhand.com> 7 * 8 * Based on wm8753.c by Liam Girdwood 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 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/slab.h> 22 #include <linux/platform_device.h> 23 #include <linux/regulator/consumer.h> 24 #include <linux/spi/spi.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 "wm8731.h" 33 34 #define WM8731_NUM_SUPPLIES 4 35 static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = { 36 "AVDD", 37 "HPVDD", 38 "DCVDD", 39 "DBVDD", 40 }; 41 42 /* codec private data */ 43 struct wm8731_priv { 44 enum snd_soc_control_type control_type; 45 struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES]; 46 unsigned int sysclk; 47 int sysclk_type; 48 int playback_fs; 49 bool deemph; 50 }; 51 52 53 /* 54 * wm8731 register cache 55 * We can't read the WM8731 register space when we are 56 * using 2 wire for device control, so we cache them instead. 57 * There is no point in caching the reset register 58 */ 59 static const u16 wm8731_reg[WM8731_CACHEREGNUM] = { 60 0x0097, 0x0097, 0x0079, 0x0079, 61 0x000a, 0x0008, 0x009f, 0x000a, 62 0x0000, 0x0000 63 }; 64 65 #define wm8731_reset(c) snd_soc_write(c, WM8731_RESET, 0) 66 67 static const char *wm8731_input_select[] = {"Line In", "Mic"}; 68 69 static const struct soc_enum wm8731_insel_enum = 70 SOC_ENUM_SINGLE(WM8731_APANA, 2, 2, wm8731_input_select); 71 72 static int wm8731_deemph[] = { 0, 32000, 44100, 48000 }; 73 74 static int wm8731_set_deemph(struct snd_soc_codec *codec) 75 { 76 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 77 int val, i, best; 78 79 /* If we're using deemphasis select the nearest available sample 80 * rate. 81 */ 82 if (wm8731->deemph) { 83 best = 1; 84 for (i = 2; i < ARRAY_SIZE(wm8731_deemph); i++) { 85 if (abs(wm8731_deemph[i] - wm8731->playback_fs) < 86 abs(wm8731_deemph[best] - wm8731->playback_fs)) 87 best = i; 88 } 89 90 val = best << 1; 91 } else { 92 best = 0; 93 val = 0; 94 } 95 96 dev_dbg(codec->dev, "Set deemphasis %d (%dHz)\n", 97 best, wm8731_deemph[best]); 98 99 return snd_soc_update_bits(codec, WM8731_APDIGI, 0x6, val); 100 } 101 102 static int wm8731_get_deemph(struct snd_kcontrol *kcontrol, 103 struct snd_ctl_elem_value *ucontrol) 104 { 105 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 106 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 107 108 ucontrol->value.enumerated.item[0] = wm8731->deemph; 109 110 return 0; 111 } 112 113 static int wm8731_put_deemph(struct snd_kcontrol *kcontrol, 114 struct snd_ctl_elem_value *ucontrol) 115 { 116 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 117 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 118 int deemph = ucontrol->value.enumerated.item[0]; 119 int ret = 0; 120 121 if (deemph > 1) 122 return -EINVAL; 123 124 mutex_lock(&codec->mutex); 125 if (wm8731->deemph != deemph) { 126 wm8731->deemph = deemph; 127 128 wm8731_set_deemph(codec); 129 130 ret = 1; 131 } 132 mutex_unlock(&codec->mutex); 133 134 return ret; 135 } 136 137 static const DECLARE_TLV_DB_SCALE(in_tlv, -3450, 150, 0); 138 static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -1500, 300, 0); 139 static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1); 140 static const DECLARE_TLV_DB_SCALE(mic_tlv, 0, 2000, 0); 141 142 static const struct snd_kcontrol_new wm8731_snd_controls[] = { 143 144 SOC_DOUBLE_R_TLV("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V, 145 0, 127, 0, out_tlv), 146 SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V, 147 7, 1, 0), 148 149 SOC_DOUBLE_R_TLV("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0, 150 in_tlv), 151 SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1), 152 153 SOC_SINGLE_TLV("Mic Boost Volume", WM8731_APANA, 0, 1, 0, mic_tlv), 154 SOC_SINGLE("Mic Capture Switch", WM8731_APANA, 1, 1, 1), 155 156 SOC_SINGLE_TLV("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1, 157 sidetone_tlv), 158 159 SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1), 160 SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0), 161 162 SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0, 163 wm8731_get_deemph, wm8731_put_deemph), 164 }; 165 166 /* Output Mixer */ 167 static const struct snd_kcontrol_new wm8731_output_mixer_controls[] = { 168 SOC_DAPM_SINGLE("Line Bypass Switch", WM8731_APANA, 3, 1, 0), 169 SOC_DAPM_SINGLE("Mic Sidetone Switch", WM8731_APANA, 5, 1, 0), 170 SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0), 171 }; 172 173 /* Input mux */ 174 static const struct snd_kcontrol_new wm8731_input_mux_controls = 175 SOC_DAPM_ENUM("Input Select", wm8731_insel_enum); 176 177 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = { 178 SND_SOC_DAPM_SUPPLY("ACTIVE",WM8731_ACTIVE, 0, 0, NULL, 0), 179 SND_SOC_DAPM_SUPPLY("OSC", WM8731_PWR, 5, 1, NULL, 0), 180 SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1, 181 &wm8731_output_mixer_controls[0], 182 ARRAY_SIZE(wm8731_output_mixer_controls)), 183 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8731_PWR, 3, 1), 184 SND_SOC_DAPM_OUTPUT("LOUT"), 185 SND_SOC_DAPM_OUTPUT("LHPOUT"), 186 SND_SOC_DAPM_OUTPUT("ROUT"), 187 SND_SOC_DAPM_OUTPUT("RHPOUT"), 188 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8731_PWR, 2, 1), 189 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &wm8731_input_mux_controls), 190 SND_SOC_DAPM_PGA("Line Input", WM8731_PWR, 0, 1, NULL, 0), 191 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8731_PWR, 1, 1), 192 SND_SOC_DAPM_INPUT("MICIN"), 193 SND_SOC_DAPM_INPUT("RLINEIN"), 194 SND_SOC_DAPM_INPUT("LLINEIN"), 195 }; 196 197 static int wm8731_check_osc(struct snd_soc_dapm_widget *source, 198 struct snd_soc_dapm_widget *sink) 199 { 200 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(source->codec); 201 202 return wm8731->sysclk_type == WM8731_SYSCLK_XTAL; 203 } 204 205 static const struct snd_soc_dapm_route wm8731_intercon[] = { 206 {"DAC", NULL, "OSC", wm8731_check_osc}, 207 {"ADC", NULL, "OSC", wm8731_check_osc}, 208 {"DAC", NULL, "ACTIVE"}, 209 {"ADC", NULL, "ACTIVE"}, 210 211 /* output mixer */ 212 {"Output Mixer", "Line Bypass Switch", "Line Input"}, 213 {"Output Mixer", "HiFi Playback Switch", "DAC"}, 214 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"}, 215 216 /* outputs */ 217 {"RHPOUT", NULL, "Output Mixer"}, 218 {"ROUT", NULL, "Output Mixer"}, 219 {"LHPOUT", NULL, "Output Mixer"}, 220 {"LOUT", NULL, "Output Mixer"}, 221 222 /* input mux */ 223 {"Input Mux", "Line In", "Line Input"}, 224 {"Input Mux", "Mic", "Mic Bias"}, 225 {"ADC", NULL, "Input Mux"}, 226 227 /* inputs */ 228 {"Line Input", NULL, "LLINEIN"}, 229 {"Line Input", NULL, "RLINEIN"}, 230 {"Mic Bias", NULL, "MICIN"}, 231 }; 232 233 struct _coeff_div { 234 u32 mclk; 235 u32 rate; 236 u16 fs; 237 u8 sr:4; 238 u8 bosr:1; 239 u8 usb:1; 240 }; 241 242 /* codec mclk clock divider coefficients */ 243 static const struct _coeff_div coeff_div[] = { 244 /* 48k */ 245 {12288000, 48000, 256, 0x0, 0x0, 0x0}, 246 {18432000, 48000, 384, 0x0, 0x1, 0x0}, 247 {12000000, 48000, 250, 0x0, 0x0, 0x1}, 248 249 /* 32k */ 250 {12288000, 32000, 384, 0x6, 0x0, 0x0}, 251 {18432000, 32000, 576, 0x6, 0x1, 0x0}, 252 {12000000, 32000, 375, 0x6, 0x0, 0x1}, 253 254 /* 8k */ 255 {12288000, 8000, 1536, 0x3, 0x0, 0x0}, 256 {18432000, 8000, 2304, 0x3, 0x1, 0x0}, 257 {11289600, 8000, 1408, 0xb, 0x0, 0x0}, 258 {16934400, 8000, 2112, 0xb, 0x1, 0x0}, 259 {12000000, 8000, 1500, 0x3, 0x0, 0x1}, 260 261 /* 96k */ 262 {12288000, 96000, 128, 0x7, 0x0, 0x0}, 263 {18432000, 96000, 192, 0x7, 0x1, 0x0}, 264 {12000000, 96000, 125, 0x7, 0x0, 0x1}, 265 266 /* 44.1k */ 267 {11289600, 44100, 256, 0x8, 0x0, 0x0}, 268 {16934400, 44100, 384, 0x8, 0x1, 0x0}, 269 {12000000, 44100, 272, 0x8, 0x1, 0x1}, 270 271 /* 88.2k */ 272 {11289600, 88200, 128, 0xf, 0x0, 0x0}, 273 {16934400, 88200, 192, 0xf, 0x1, 0x0}, 274 {12000000, 88200, 136, 0xf, 0x1, 0x1}, 275 }; 276 277 static inline int get_coeff(int mclk, int rate) 278 { 279 int i; 280 281 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { 282 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) 283 return i; 284 } 285 return 0; 286 } 287 288 static int wm8731_hw_params(struct snd_pcm_substream *substream, 289 struct snd_pcm_hw_params *params, 290 struct snd_soc_dai *dai) 291 { 292 struct snd_soc_codec *codec = dai->codec; 293 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 294 u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3; 295 int i = get_coeff(wm8731->sysclk, params_rate(params)); 296 u16 srate = (coeff_div[i].sr << 2) | 297 (coeff_div[i].bosr << 1) | coeff_div[i].usb; 298 299 wm8731->playback_fs = params_rate(params); 300 301 snd_soc_write(codec, WM8731_SRATE, srate); 302 303 /* bit size */ 304 switch (params_format(params)) { 305 case SNDRV_PCM_FORMAT_S16_LE: 306 break; 307 case SNDRV_PCM_FORMAT_S20_3LE: 308 iface |= 0x0004; 309 break; 310 case SNDRV_PCM_FORMAT_S24_LE: 311 iface |= 0x0008; 312 break; 313 } 314 315 wm8731_set_deemph(codec); 316 317 snd_soc_write(codec, WM8731_IFACE, iface); 318 return 0; 319 } 320 321 static int wm8731_mute(struct snd_soc_dai *dai, int mute) 322 { 323 struct snd_soc_codec *codec = dai->codec; 324 u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7; 325 326 if (mute) 327 snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8); 328 else 329 snd_soc_write(codec, WM8731_APDIGI, mute_reg); 330 return 0; 331 } 332 333 static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai, 334 int clk_id, unsigned int freq, int dir) 335 { 336 struct snd_soc_codec *codec = codec_dai->codec; 337 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 338 339 switch (clk_id) { 340 case WM8731_SYSCLK_XTAL: 341 case WM8731_SYSCLK_MCLK: 342 wm8731->sysclk_type = clk_id; 343 break; 344 default: 345 return -EINVAL; 346 } 347 348 switch (freq) { 349 case 11289600: 350 case 12000000: 351 case 12288000: 352 case 16934400: 353 case 18432000: 354 wm8731->sysclk = freq; 355 break; 356 default: 357 return -EINVAL; 358 } 359 360 snd_soc_dapm_sync(&codec->dapm); 361 362 return 0; 363 } 364 365 366 static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai, 367 unsigned int fmt) 368 { 369 struct snd_soc_codec *codec = codec_dai->codec; 370 u16 iface = 0; 371 372 /* set master/slave audio interface */ 373 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 374 case SND_SOC_DAIFMT_CBM_CFM: 375 iface |= 0x0040; 376 break; 377 case SND_SOC_DAIFMT_CBS_CFS: 378 break; 379 default: 380 return -EINVAL; 381 } 382 383 /* interface format */ 384 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 385 case SND_SOC_DAIFMT_I2S: 386 iface |= 0x0002; 387 break; 388 case SND_SOC_DAIFMT_RIGHT_J: 389 break; 390 case SND_SOC_DAIFMT_LEFT_J: 391 iface |= 0x0001; 392 break; 393 case SND_SOC_DAIFMT_DSP_A: 394 iface |= 0x0003; 395 break; 396 case SND_SOC_DAIFMT_DSP_B: 397 iface |= 0x0013; 398 break; 399 default: 400 return -EINVAL; 401 } 402 403 /* clock inversion */ 404 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 405 case SND_SOC_DAIFMT_NB_NF: 406 break; 407 case SND_SOC_DAIFMT_IB_IF: 408 iface |= 0x0090; 409 break; 410 case SND_SOC_DAIFMT_IB_NF: 411 iface |= 0x0080; 412 break; 413 case SND_SOC_DAIFMT_NB_IF: 414 iface |= 0x0010; 415 break; 416 default: 417 return -EINVAL; 418 } 419 420 /* set iface */ 421 snd_soc_write(codec, WM8731_IFACE, iface); 422 return 0; 423 } 424 425 static int wm8731_set_bias_level(struct snd_soc_codec *codec, 426 enum snd_soc_bias_level level) 427 { 428 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 429 int i, ret; 430 u8 data[2]; 431 u16 *cache = codec->reg_cache; 432 u16 reg; 433 434 switch (level) { 435 case SND_SOC_BIAS_ON: 436 break; 437 case SND_SOC_BIAS_PREPARE: 438 break; 439 case SND_SOC_BIAS_STANDBY: 440 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) { 441 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), 442 wm8731->supplies); 443 if (ret != 0) 444 return ret; 445 446 /* Sync reg_cache with the hardware */ 447 for (i = 0; i < ARRAY_SIZE(wm8731_reg); i++) { 448 if (cache[i] == wm8731_reg[i]) 449 continue; 450 451 data[0] = (i << 1) | ((cache[i] >> 8) 452 & 0x0001); 453 data[1] = cache[i] & 0x00ff; 454 codec->hw_write(codec->control_data, data, 2); 455 } 456 } 457 458 /* Clear PWROFF, gate CLKOUT, everything else as-is */ 459 reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f; 460 snd_soc_write(codec, WM8731_PWR, reg | 0x0040); 461 break; 462 case SND_SOC_BIAS_OFF: 463 snd_soc_write(codec, WM8731_PWR, 0xffff); 464 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), 465 wm8731->supplies); 466 break; 467 } 468 codec->dapm.bias_level = level; 469 return 0; 470 } 471 472 #define WM8731_RATES SNDRV_PCM_RATE_8000_96000 473 474 #define WM8731_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 475 SNDRV_PCM_FMTBIT_S24_LE) 476 477 static struct snd_soc_dai_ops wm8731_dai_ops = { 478 .hw_params = wm8731_hw_params, 479 .digital_mute = wm8731_mute, 480 .set_sysclk = wm8731_set_dai_sysclk, 481 .set_fmt = wm8731_set_dai_fmt, 482 }; 483 484 static struct snd_soc_dai_driver wm8731_dai = { 485 .name = "wm8731-hifi", 486 .playback = { 487 .stream_name = "Playback", 488 .channels_min = 1, 489 .channels_max = 2, 490 .rates = WM8731_RATES, 491 .formats = WM8731_FORMATS,}, 492 .capture = { 493 .stream_name = "Capture", 494 .channels_min = 1, 495 .channels_max = 2, 496 .rates = WM8731_RATES, 497 .formats = WM8731_FORMATS,}, 498 .ops = &wm8731_dai_ops, 499 .symmetric_rates = 1, 500 }; 501 502 #ifdef CONFIG_PM 503 static int wm8731_suspend(struct snd_soc_codec *codec, pm_message_t state) 504 { 505 wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF); 506 507 return 0; 508 } 509 510 static int wm8731_resume(struct snd_soc_codec *codec) 511 { 512 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 513 514 return 0; 515 } 516 #else 517 #define wm8731_suspend NULL 518 #define wm8731_resume NULL 519 #endif 520 521 static int wm8731_probe(struct snd_soc_codec *codec) 522 { 523 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 524 int ret = 0, i; 525 526 ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8731->control_type); 527 if (ret < 0) { 528 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); 529 return ret; 530 } 531 532 for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++) 533 wm8731->supplies[i].supply = wm8731_supply_names[i]; 534 535 ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8731->supplies), 536 wm8731->supplies); 537 if (ret != 0) { 538 dev_err(codec->dev, "Failed to request supplies: %d\n", ret); 539 return ret; 540 } 541 542 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), 543 wm8731->supplies); 544 if (ret != 0) { 545 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); 546 goto err_regulator_get; 547 } 548 549 ret = wm8731_reset(codec); 550 if (ret < 0) { 551 dev_err(codec->dev, "Failed to issue reset: %d\n", ret); 552 goto err_regulator_enable; 553 } 554 555 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 556 557 /* Latch the update bits */ 558 snd_soc_update_bits(codec, WM8731_LOUT1V, 0x100, 0); 559 snd_soc_update_bits(codec, WM8731_ROUT1V, 0x100, 0); 560 snd_soc_update_bits(codec, WM8731_LINVOL, 0x100, 0); 561 snd_soc_update_bits(codec, WM8731_RINVOL, 0x100, 0); 562 563 /* Disable bypass path by default */ 564 snd_soc_update_bits(codec, WM8731_APANA, 0x8, 0); 565 566 snd_soc_add_controls(codec, wm8731_snd_controls, 567 ARRAY_SIZE(wm8731_snd_controls)); 568 569 /* Regulators will have been enabled by bias management */ 570 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 571 572 return 0; 573 574 err_regulator_enable: 575 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 576 err_regulator_get: 577 regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 578 579 return ret; 580 } 581 582 /* power down chip */ 583 static int wm8731_remove(struct snd_soc_codec *codec) 584 { 585 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); 586 587 wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF); 588 589 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 590 regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); 591 592 return 0; 593 } 594 595 static struct snd_soc_codec_driver soc_codec_dev_wm8731 = { 596 .probe = wm8731_probe, 597 .remove = wm8731_remove, 598 .suspend = wm8731_suspend, 599 .resume = wm8731_resume, 600 .set_bias_level = wm8731_set_bias_level, 601 .reg_cache_size = ARRAY_SIZE(wm8731_reg), 602 .reg_word_size = sizeof(u16), 603 .reg_cache_default = wm8731_reg, 604 .dapm_widgets = wm8731_dapm_widgets, 605 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets), 606 .dapm_routes = wm8731_intercon, 607 .num_dapm_routes = ARRAY_SIZE(wm8731_intercon), 608 }; 609 610 #if defined(CONFIG_SPI_MASTER) 611 static int __devinit wm8731_spi_probe(struct spi_device *spi) 612 { 613 struct wm8731_priv *wm8731; 614 int ret; 615 616 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL); 617 if (wm8731 == NULL) 618 return -ENOMEM; 619 620 wm8731->control_type = SND_SOC_SPI; 621 spi_set_drvdata(spi, wm8731); 622 623 ret = snd_soc_register_codec(&spi->dev, 624 &soc_codec_dev_wm8731, &wm8731_dai, 1); 625 if (ret < 0) 626 kfree(wm8731); 627 return ret; 628 } 629 630 static int __devexit wm8731_spi_remove(struct spi_device *spi) 631 { 632 snd_soc_unregister_codec(&spi->dev); 633 kfree(spi_get_drvdata(spi)); 634 return 0; 635 } 636 637 static struct spi_driver wm8731_spi_driver = { 638 .driver = { 639 .name = "wm8731", 640 .owner = THIS_MODULE, 641 }, 642 .probe = wm8731_spi_probe, 643 .remove = __devexit_p(wm8731_spi_remove), 644 }; 645 #endif /* CONFIG_SPI_MASTER */ 646 647 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 648 static __devinit int wm8731_i2c_probe(struct i2c_client *i2c, 649 const struct i2c_device_id *id) 650 { 651 struct wm8731_priv *wm8731; 652 int ret; 653 654 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL); 655 if (wm8731 == NULL) 656 return -ENOMEM; 657 658 i2c_set_clientdata(i2c, wm8731); 659 wm8731->control_type = SND_SOC_I2C; 660 661 ret = snd_soc_register_codec(&i2c->dev, 662 &soc_codec_dev_wm8731, &wm8731_dai, 1); 663 if (ret < 0) 664 kfree(wm8731); 665 return ret; 666 } 667 668 static __devexit int wm8731_i2c_remove(struct i2c_client *client) 669 { 670 snd_soc_unregister_codec(&client->dev); 671 kfree(i2c_get_clientdata(client)); 672 return 0; 673 } 674 675 static const struct i2c_device_id wm8731_i2c_id[] = { 676 { "wm8731", 0 }, 677 { } 678 }; 679 MODULE_DEVICE_TABLE(i2c, wm8731_i2c_id); 680 681 static struct i2c_driver wm8731_i2c_driver = { 682 .driver = { 683 .name = "wm8731", 684 .owner = THIS_MODULE, 685 }, 686 .probe = wm8731_i2c_probe, 687 .remove = __devexit_p(wm8731_i2c_remove), 688 .id_table = wm8731_i2c_id, 689 }; 690 #endif 691 692 static int __init wm8731_modinit(void) 693 { 694 int ret = 0; 695 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 696 ret = i2c_add_driver(&wm8731_i2c_driver); 697 if (ret != 0) { 698 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n", 699 ret); 700 } 701 #endif 702 #if defined(CONFIG_SPI_MASTER) 703 ret = spi_register_driver(&wm8731_spi_driver); 704 if (ret != 0) { 705 printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n", 706 ret); 707 } 708 #endif 709 return ret; 710 } 711 module_init(wm8731_modinit); 712 713 static void __exit wm8731_exit(void) 714 { 715 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 716 i2c_del_driver(&wm8731_i2c_driver); 717 #endif 718 #if defined(CONFIG_SPI_MASTER) 719 spi_unregister_driver(&wm8731_spi_driver); 720 #endif 721 } 722 module_exit(wm8731_exit); 723 724 MODULE_DESCRIPTION("ASoC WM8731 driver"); 725 MODULE_AUTHOR("Richard Purdie"); 726 MODULE_LICENSE("GPL"); 727