SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/soc/codecs/wm8731.c

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