sound/soc/imx/imx32ads-wm8350.c

   1 /*
   2  * imx32ads-wm8350.c  --  i.MX31ADS Driver for Wolfson WM8350 Codec
   3  *
   4  * Copyright 2007 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Liam Girdwood
   7  *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
   8  *
   9  *  This program is free software; you can redistribute  it and/or modify it
  10  *  under  the terms of  the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the  License, or (at your
  12  *  option) any later version.
  13  *
  14  *  Revision history
  15  *    19th Jun 2007   Initial version.
  16  *
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/moduleparam.h>
  21 #include <linux/init.h>
  22 #include <linux/delay.h>
  23 #include <linux/pm.h>
  24 #include <linux/bitops.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/i2c.h>
  27 #include <linux/err.h>
  28 #include <linux/regulator/regulator.h>
  29 #include <linux/regulator/wm8350/audio.h>
  30 #include <linux/regulator/wm8350/bus.h>
  31 #include <sound/driver.h>
  32 #include <sound/core.h>
  33 #include <sound/pcm.h>
  34 #include <sound/pcm_params.h>
  35 #include <sound/soc.h>
  36 #include <sound/soc-dapm.h>
  37 #include <sound/initval.h>
  38
  39 #include <asm/arch/dma.h>
  40 #include <asm/arch/spba.h>
  41 #include <asm/arch/clock.h>
  42
  43 #include "../sound/soc/imx/imx-ssi.h"
  44 #include "../sound/soc/imx/imx31-pcm.h"
  45
  46 /* SSI BCLK and LRC master */
  47 #define WM8350_SSI_MASTER       1
  48 /* clock select - either MCLK 0 or 32K 1 */
  49 #define WM8350_USE_FLL_32K      1
  50
  51 #define IMX31ADS_AUDIO_VERSION "0.4"
  52
  53 #define WM8350_AVDD 3300000
  54
  55 struct imx31ads_pcm_state {
  56         int lr_clk_active;
  57         int playback_active;
  58         int capture_active;
  59 };
  60
  61 struct imx31ads_data {
  62         struct regulator *analog_supply;
  63         struct wm8350 *wm8350;
  64 };
  65
  66 struct _wm8350_audio {
  67         unsigned int channels;
  68         snd_pcm_format_t format;
  69         unsigned int rate;
  70         unsigned int sysclk;
  71         unsigned int bclkdiv;
  72         unsigned int clkdiv;
  73         unsigned int lr_rate;
  74 };
  75
  76 /* in order of power consumption per rate (lowest first) */
  77 static const struct _wm8350_audio wm8350_audio[] = {
  78         /* 16bit mono modes */
  79         {1, SNDRV_PCM_FORMAT_S16_LE, 8000, 12288000 >> 1,
  80          WM8350_BCLK_DIV_48, WM8350_DACDIV_3, 16,},
  81
  82         /* 16 bit stereo modes */
  83         {2, SNDRV_PCM_FORMAT_S16_LE, 8000, 12288000,
  84          WM8350_BCLK_DIV_48, WM8350_DACDIV_6, 32,},
  85         {2, SNDRV_PCM_FORMAT_S16_LE, 16000, 12288000,
  86          WM8350_BCLK_DIV_24, WM8350_DACDIV_3, 32,},
  87         {2, SNDRV_PCM_FORMAT_S16_LE, 32000, 12288000,
  88          WM8350_BCLK_DIV_12, WM8350_DACDIV_1_5, 32,},
  89         {2, SNDRV_PCM_FORMAT_S16_LE, 48000, 12288000,
  90          WM8350_BCLK_DIV_8, WM8350_DACDIV_1, 32,},
  91         {2, SNDRV_PCM_FORMAT_S16_LE, 96000, 24576000,
  92          WM8350_BCLK_DIV_8, WM8350_DACDIV_1, 32,},
  93         {2, SNDRV_PCM_FORMAT_S16_LE, 11025, 11289600,
  94          WM8350_BCLK_DIV_32, WM8350_DACDIV_4, 32,},
  95         {2, SNDRV_PCM_FORMAT_S16_LE, 22050, 11289600,
  96          WM8350_BCLK_DIV_16, WM8350_DACDIV_2, 32,},
  97         {2, SNDRV_PCM_FORMAT_S16_LE, 44100, 11289600,
  98          WM8350_BCLK_DIV_8, WM8350_DACDIV_1, 32,},
  99         {2, SNDRV_PCM_FORMAT_S16_LE, 88200, 22579200,
 100          WM8350_BCLK_DIV_8, WM8350_DACDIV_1, 32,},
 101
 102         /* 24bit stereo modes */
 103         {2, SNDRV_PCM_FORMAT_S24_LE, 48000, 12288000,
 104          WM8350_BCLK_DIV_4, WM8350_DACDIV_1, 64,},
 105         {2, SNDRV_PCM_FORMAT_S24_LE, 96000, 24576000,
 106          WM8350_BCLK_DIV_4, WM8350_DACDIV_1, 64,},
 107         {2, SNDRV_PCM_FORMAT_S24_LE, 44100, 11289600,
 108          WM8350_BCLK_DIV_4, WM8350_DACDIV_1, 64,},
 109         {2, SNDRV_PCM_FORMAT_S24_LE, 88200, 22579200,
 110          WM8350_BCLK_DIV_4, WM8350_DACDIV_1, 64,},
 111 };
 112
 113 #if WM8350_SSI_MASTER
 114 static int imx32ads_startup(struct snd_pcm_substream *substream)
 115 {
 116         struct snd_soc_pcm_runtime *pcm_runtime = substream->private_data;
 117         struct snd_soc_codec *codec = pcm_runtime->codec;
 118         struct wm8350 *wm8350 = codec->control_data;
 119         struct imx31ads_pcm_state *state = pcm_runtime->private_data;
 120
 121         /* In master mode the LR clock can come from either the DAC or ADC.
 122          * We use the LR clock from whatever stream is enabled first.
 123          */
 124         if (!state->lr_clk_active) {
 125                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 126                         wm8350_clear_bits(wm8350, WM8350_CLOCK_CONTROL_2,
 127                                           WM8350_LRC_ADC_SEL);
 128                 else
 129                         wm8350_set_bits(wm8350, WM8350_CLOCK_CONTROL_2,
 130                                         WM8350_LRC_ADC_SEL);
 131         }
 132         state->lr_clk_active++;
 133         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 134                 state->capture_active = 1;
 135         else
 136                 state->playback_active = 1;
 137         return 0;
 138 }
 139 #else
 140 #define imx32ads_startup NULL
 141 #endif
 142
 143 static int imx32ads_hifi_hw_params(struct snd_pcm_substream *substream,
 144                                    struct snd_pcm_hw_params *params)
 145 {
 146         struct snd_soc_pcm_runtime *pcm_runtime = substream->private_data;
 147         struct snd_soc_dai *cpu_dai = pcm_runtime->cpu_dai;
 148         struct snd_soc_dai *codec_dai = pcm_runtime->codec_dai;
 149         struct imx31ads_pcm_state *state = pcm_runtime->private_data;
 150         int i, found = 0;
 151         snd_pcm_format_t format = params_format(params);
 152         unsigned int rate = params_rate(params);
 153         unsigned int channels = params_channels(params);
 154         u32 dai_format;
 155
 156         /* only need to do this once as capture and playback are sync */
 157         if (state->lr_clk_active > 1)
 158                 return 0;
 159
 160         /* find the correct audio parameters */
 161         for (i = 0; i < ARRAY_SIZE(wm8350_audio); i++) {
 162                 if (rate == wm8350_audio[i].rate &&
 163                     format == wm8350_audio[i].format &&
 164                     channels == wm8350_audio[i].channels) {
 165                         found = 1;
 166                         break;
 167                 }
 168         }
 169         if (!found)
 170                 return -EINVAL;
 171
 172 #if WM8350_SSI_MASTER
 173         dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 174             SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_SYNC;
 175         if (channels == 2)
 176                 dai_format |= SND_SOC_DAIFMT_TDM;
 177
 178         /* set codec DAI configuration */
 179         snd_soc_dai_set_fmt(codec_dai, dai_format);
 180
 181         /* set cpu DAI configuration */
 182         snd_soc_dai_set_fmt(cpu_dai, dai_format);
 183
 184 #if WM8350_USE_FLL_32K
 185         /* set 32K clock as the codec system clock for DAC and ADC */
 186         snd_soc_dai_set_sysclk(codec_dai, WM8350_MCLK_SEL_PLL_32K,
 187                                wm8350_audio[i].sysclk, SND_SOC_CLOCK_IN);
 188 #else
 189         /* set MCLK as the codec system clock for DAC and ADC */
 190         snd_soc_dai_set_sysclk(codec_dai, WM8350_MCLK_SEL_PLL_MCLK,
 191                                wm8350_audio[i].sysclk, SND_SOC_CLOCK_IN);
 192 #endif
 193
 194 #else
 195
 196         dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 197             SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_SYNC;
 198         if (channels == 2)
 199                 format |= SND_SOC_DAIFMT_TDM;
 200
 201         /* set codec DAI configuration */
 202         snd_soc_dai_set_fmt(codec_dai, dai_format);
 203
 204         /* set cpu DAI configuration */
 205         snd_soc_dai_set_fmt(cpu_dai, dai_format);
 206
 207         /* set DAC LRC as the codec system clock for DAC and ADC */
 208         snd_soc_dai_set_sysclk(codec_dai, WM8350_MCLK_SEL_PLL_DAC,
 209                                wm8350_audio[i].sysclk, SND_SOC_CLOCK_IN);
 210 #endif
 211
 212         /* set i.MX active slot mask */
 213         snd_soc_dai_set_tdm_slot(cpu_dai,
 214                                  channels == 1 ? 0xfffffffe : 0xfffffffc,
 215                                  channels);
 216
 217         /* set the SSI system clock as input (unused) */
 218         snd_soc_dai_set_sysclk(cpu_dai, IMX_SSP_SYS_CLK, 0, SND_SOC_CLOCK_IN);
 219
 220         /* set codec BCLK division for sample rate */
 221         snd_soc_dai_set_clkdiv(codec_dai, WM8350_BCLK_CLKDIV,
 222                                wm8350_audio[i].bclkdiv);
 223
 224         /* DAI is synchronous and clocked with DAC LRCLK & ADC LRC */
 225         snd_soc_dai_set_clkdiv(codec_dai,
 226                                WM8350_DACLR_CLKDIV, wm8350_audio[i].lr_rate);
 227         snd_soc_dai_set_clkdiv(codec_dai,
 228                                WM8350_ADCLR_CLKDIV, wm8350_audio[i].lr_rate);
 229
 230         /* now configure DAC and ADC clocks */
 231         snd_soc_dai_set_clkdiv(codec_dai,
 232                                WM8350_DAC_CLKDIV, wm8350_audio[i].clkdiv);
 233
 234         snd_soc_dai_set_clkdiv(codec_dai,
 235                                WM8350_ADC_CLKDIV, wm8350_audio[i].clkdiv);
 236
 237 #if WM8350_SSI_MASTER
 238 #if WM8350_USE_FLL_32K
 239         /* codec FLL input is 32 kHz from WM8350 */
 240         snd_soc_dai_set_pll(codec_dai, 0, 32000, wm8350_audio[i].sysclk);
 241 #else
 242         /* codec FLL input is 14.75 MHz from MCLK */
 243         snd_soc_dai_set_pll(codec_dai, 0, 14750000, wm8350_audio[i].sysclk);
 244 #endif
 245 #else
 246         /* codec FLL input is rate from DAC LRC */
 247         snd_soc_dai_set_pll(codec_dai, 0, rate, wm8350_audio[i].sysclk);
 248 #endif
 249
 250         return 0;
 251 }
 252
 253 static void imx32ads_shutdown(struct snd_pcm_substream *substream)
 254 {
 255         struct snd_soc_pcm_runtime *pcm_runtime = substream->private_data;
 256         struct snd_soc_dai *codec_dai = pcm_runtime->codec_dai;
 257         struct snd_soc_codec *codec = pcm_runtime->codec;
 258         struct imx31ads_pcm_state *state = pcm_runtime->private_data;
 259         struct wm8350 *wm8350 = codec->control_data;
 260
 261         /* disable the PLL if there are no active Tx or Rx channels */
 262         if (!codec->active)
 263                 snd_soc_dai_set_pll(codec_dai, 0, 0, 0);
 264         state->lr_clk_active--;
 265
 266         /*
 267          * We need to keep track of active streams in master mode and
 268          * switch LRC source if necessary.
 269          */
 270
 271         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 272                 state->capture_active = 0;
 273         else
 274                 state->playback_active = 0;
 275
 276         if (state->capture_active)
 277                 wm8350_set_bits(wm8350, WM8350_CLOCK_CONTROL_2,
 278                                 WM8350_LRC_ADC_SEL);
 279         else if (state->playback_active)
 280                 wm8350_clear_bits(wm8350, WM8350_CLOCK_CONTROL_2,
 281                                   WM8350_LRC_ADC_SEL);
 282 }
 283
 284 /*
 285  * imx32ads WM8350 HiFi DAI opserations.
 286  */
 287 static struct snd_soc_ops imx32ads_hifi_ops = {
 288         .startup = imx32ads_startup,
 289         .shutdown = imx32ads_shutdown,
 290         .hw_params = imx32ads_hifi_hw_params,
 291 };
 292
 293 /* need to refine these */
 294 static struct wm8350_audio_platform_data imx32ads_wm8350_setup = {
 295         .vmid_discharge_msecs = 1000,
 296         .drain_msecs = 30,
 297         .cap_discharge_msecs = 700,
 298         .vmid_charge_msecs = 700,
 299         .vmid_s_curve = WM8350_S_CURVE_SLOW,
 300         .dis_out4 = WM8350_DISCHARGE_SLOW,
 301         .dis_out3 = WM8350_DISCHARGE_SLOW,
 302         .dis_out2 = WM8350_DISCHARGE_SLOW,
 303         .dis_out1 = WM8350_DISCHARGE_SLOW,
 304         .vroi_out4 = WM8350_TIE_OFF_500R,
 305         .vroi_out3 = WM8350_TIE_OFF_500R,
 306         .vroi_out2 = WM8350_TIE_OFF_500R,
 307         .vroi_out1 = WM8350_TIE_OFF_500R,
 308         .vroi_enable = 0,
 309         .codec_current_on = WM8350_CODEC_ISEL_1_0,
 310         .codec_current_standby = WM8350_CODEC_ISEL_0_5,
 311         .codec_current_charge = WM8350_CODEC_ISEL_1_5,
 312 };
 313
 314 /* imx32ads soc_card dapm widgets */
 315 static const struct snd_soc_dapm_widget imx32ads_dapm_widgets[] = {
 316         SND_SOC_DAPM_MIC("SiMIC", NULL),
 317         SND_SOC_DAPM_MIC("Mic1 Jack", NULL),
 318         SND_SOC_DAPM_MIC("Mic2 Jack", NULL),
 319         SND_SOC_DAPM_LINE("Line In Jack", NULL),
 320         SND_SOC_DAPM_LINE("Line Out Jack", NULL),
 321         SND_SOC_DAPM_HP("Headphone Jack", NULL),
 322 };
 323
 324 /* imx32ads soc_card audio map */
 325 static const struct snd_soc_dapm_route audio_map[] = {
 326
 327         /* SiMIC --> IN1LN (with automatic bias) via SP1 */
 328         {"IN1LN", NULL, "Mic Bias"},
 329         {"Mic Bias", NULL, "SiMIC"},
 330
 331         /* Mic 1 Jack --> IN1LN and IN1LP (with automatic bias) */
 332         {"IN1LN", NULL, "Mic Bias"},
 333         {"IN1LP", NULL, "Mic1 Jack"},
 334         {"Mic Bias", NULL, "Mic1 Jack"},
 335
 336         /* Mic 2 Jack --> IN1RN and IN1RP (with automatic bias) */
 337         {"IN1RN", NULL, "Mic Bias"},
 338         {"IN1RP", NULL, "Mic1 Jack"},
 339         {"Mic Bias", NULL, "Mic1 Jack"},
 340
 341         /* Line in Jack --> AUX (L+R) */
 342         {"IN3R", NULL, "Line In Jack"},
 343         {"IN3L", NULL, "Line In Jack"},
 344
 345         /* Out1 --> Headphone Jack */
 346         {"Headphone Jack", NULL, "OUT1R"},
 347         {"Headphone Jack", NULL, "OUT1L"},
 348
 349         /* Out1 --> Line Out Jack */
 350         {"Line Out Jack", NULL, "OUT2R"},
 351         {"Line Out Jack", NULL, "OUT2L"},
 352 };
 353
 354 #ifdef CONFIG_PM
 355 static int imx32ads_wm8350_audio_suspend(struct platform_device *pdev,
 356                                          pm_message_t state)
 357 {
 358         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 359         struct snd_soc_card *soc_card = wm8350->audio;
 360
 361         return snd_soc_card_suspend_pcms(soc_card, state);
 362 }
 363
 364 static int imx32ads_wm8350_audio_resume(struct platform_device *pdev)
 365 {
 366         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 367         struct snd_soc_card *soc_card = wm8350->audio;
 368
 369         return snd_soc_card_resume_pcms(soc_card);
 370 }
 371
 372 #else
 373 #define imx32ads_wm8350_audio_suspend   NULL
 374 #define imx32ads_wm8350_audio_resume    NULL
 375 #endif
 376
 377 static void imx32ads_jack_handler(struct wm8350 *wm8350, int irq, void *data)
 378 {
 379         struct snd_soc_card *soc_card = (struct snd_soc_card *)data;
 380         u16 reg;
 381
 382         /* debounce for 200ms */
 383         schedule_timeout_interruptible(msecs_to_jiffies(200));
 384         reg = wm8350_reg_read(wm8350, WM8350_JACK_PIN_STATUS);
 385
 386         if (reg & WM8350_JACK_R_LVL) {
 387                 snd_soc_dapm_disable_pin(soc_card, "Line Out Jack");
 388                 snd_soc_dapm_enable_pin(soc_card, "Headphone Jack");
 389         } else {
 390                 snd_soc_dapm_disable_pin(soc_card, "Headphone Jack");
 391                 snd_soc_dapm_enable_pin(soc_card, "Line Out Jack");
 392         }
 393         snd_soc_dapm_sync(soc_card);
 394 }
 395
 396 int imx32_audio_init(struct snd_soc_card *soc_card)
 397 {
 398         struct snd_soc_codec *codec;
 399         struct snd_soc_pcm_runtime *pcm_runtime;
 400         struct imx31ads_data *audio_data = soc_card->private_data;
 401         struct wm8350 *wm8350 = audio_data->wm8350;
 402         struct imx31ads_pcm_state *state;
 403         int ret;
 404         u16 reg;
 405
 406         pcm_runtime = snd_soc_card_get_pcm(soc_card, "HiFi");
 407         if (pcm_runtime == NULL)
 408                 return -ENODEV;
 409
 410         codec = snd_soc_card_get_codec(soc_card, wm8350_codec_id);
 411         if (codec == NULL)
 412                 return -ENODEV;
 413
 414         state = kzalloc(sizeof(struct imx31ads_pcm_state), GFP_KERNEL);
 415         if (state == NULL)
 416                 return -ENOMEM;
 417         pcm_runtime->private_data = state;
 418
 419         codec->platform_data = &imx32ads_wm8350_setup;
 420         snd_soc_card_config_codec(codec, NULL, NULL,    wm8350);
 421         snd_soc_card_init_codec(codec, soc_card);
 422
 423 #if 0
 424         /* add imx32ads specific controls */
 425         for (i = 0; i < ARRAY_SIZE(imx32ads_wm8350_audio_controls); i++) {
 426                 if ((err = snd_ctl_add(soc_card->card,
 427                                 snd_soc_cnew(&imx32ads_wm8350_audio_controls[i],
 428                                         codec, NULL))) < 0)
 429                         return err;
 430         }
 431 #endif
 432
 433         /* Add imx32ads specific widgets */
 434         ret = snd_soc_dapm_new_controls(soc_card, codec,
 435                                         imx32ads_dapm_widgets,
 436                                         ARRAY_SIZE(imx32ads_dapm_widgets));
 437         if (ret < 0)
 438                 return ret;
 439
 440         /* set up imx32ads specific audio path audio map */
 441         ret = snd_soc_dapm_add_routes(soc_card, audio_map,
 442                 ARRAY_SIZE(audio_map));
 443         if (ret < 0)
 444                 return ret;
 445
 446         /* disable unused imx32ads WM8350 codec pins */
 447         snd_soc_dapm_disable_pin(soc_card, "OUT3");
 448         snd_soc_dapm_disable_pin(soc_card, "OUT4");
 449         snd_soc_dapm_disable_pin(soc_card, "IN2R");
 450         snd_soc_dapm_disable_pin(soc_card, "IN2L");
 451         snd_soc_dapm_disable_pin(soc_card, "OUT2L");
 452         snd_soc_dapm_disable_pin(soc_card, "OUT2R");
 453
 454         /* connect and enable all imx32ads WM8350 jacks (for now) */
 455         snd_soc_dapm_enable_pin(soc_card, "SiMIC");
 456         snd_soc_dapm_enable_pin(soc_card, "Mic1 Jack");
 457         snd_soc_dapm_enable_pin(soc_card, "Mic2 Jack");
 458         snd_soc_dapm_enable_pin(soc_card, "Line In Jack");
 459         snd_soc_dapm_set_policy(soc_card, SND_SOC_DAPM_POLICY_AUTOMATIC);
 460         snd_soc_dapm_sync(soc_card);
 461
 462         /* enable slow clock gen for jack detect */
 463         reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_4);
 464         wm8350_reg_write(wm8350, WM8350_POWER_MGMT_4, reg | WM8350_TOCLK_ENA);
 465
 466         /* enable jack detect */
 467         reg = wm8350_reg_read(wm8350, WM8350_JACK_DETECT);
 468         wm8350_reg_write(wm8350, WM8350_JACK_DETECT, reg | WM8350_JDR_ENA);
 469         wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R,
 470                             imx32ads_jack_handler, soc_card);
 471         wm8350_unmask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
 472
 473         return 0;
 474 }
 475
 476 static void imx32_audio_exit(struct snd_soc_card *soc_card)
 477 {
 478         struct snd_soc_pcm_runtime *pcm_runtime;
 479
 480         pcm_runtime = snd_soc_card_get_pcm(soc_card, "HiFi");
 481         if (pcm_runtime)
 482                 kfree(pcm_runtime->private_data);
 483 }
 484
 485 static struct snd_soc_pcm_config hifi_pcm_config = {
 486         .name = "HiFi",
 487         .codec = wm8350_codec_id,
 488         .codec_dai = wm8350_codec_dai_id,
 489         .platform = imx31_platform_id,
 490         .cpu_dai = imx_ssi_id1_0,
 491         .ops = &imx32ads_hifi_ops,
 492         .playback = 1,
 493         .capture = 1,
 494 };
 495
 496 static int __devinit imx32ads_wm8350_audio_probe(struct platform_device *pdev)
 497 {
 498         struct snd_soc_card *soc_card;
 499         struct imx31ads_data *audio_data;
 500         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 501         int ret;
 502
 503         printk(KERN_INFO "i.MX32ADS WM8350 audio\n");
 504         audio_data = kzalloc(sizeof(*audio_data), GFP_KERNEL);
 505         if (audio_data == NULL)
 506                 return -ENOMEM;
 507
 508         ret = get_ssi_clk(0, &pdev->dev);
 509         if (ret < 0) {
 510                 printk(KERN_ERR "%s: cant get ssi clock\n", __func__);
 511                 goto ssi_err;
 512         }
 513         audio_data->analog_supply = regulator_get(&pdev->dev, "codec_avdd");
 514         if (IS_ERR(audio_data->analog_supply)) {
 515                 printk(KERN_ERR "%s: cant get regulator\n", __func__);
 516                 goto ssi_err;
 517         }
 518         ret = regulator_set_voltage(audio_data->analog_supply, WM8350_AVDD,
 519                 WM8350_AVDD);
 520         if (ret < 0) {
 521                 printk(KERN_ERR "%s: cant set voltage\n", __func__);
 522                 goto reg_err;
 523         }
 524         ret = regulator_enable(audio_data->analog_supply);
 525         if (ret < 0) {
 526                 printk(KERN_ERR "%s: cant enable regulator\n", __func__);
 527                 goto reg_err;
 528         }
 529
 530         soc_card = snd_soc_card_create("imx31ads", &pdev->dev,
 531                                          SNDRV_DEFAULT_IDX1,
 532                                          SNDRV_DEFAULT_STR1);
 533         if (soc_card == NULL) {
 534                 ret = -ENOMEM;
 535                 goto reg_err;
 536         }
 537
 538         audio_data->wm8350 = wm8350;
 539         soc_card->longname = "WM8350";
 540         soc_card->init = imx32_audio_init,
 541         soc_card->exit = imx32_audio_exit,
 542         soc_card->private_data = audio_data;
 543         soc_card->dev = &pdev->dev;
 544         wm8350->audio = soc_card;
 545
 546         ret = snd_soc_card_create_pcms(soc_card, &hifi_pcm_config, 1);
 547         if (ret < 0)
 548                 goto err;
 549
 550         /* WM8350 uses SSI1 via AUDMUX port 5 for audio */
 551
 552         /* reset port 1 & 5 */
 553         DAM_PTCR1 = 0;
 554         DAM_PDCR1 = 0;
 555         DAM_PTCR5 = 0;
 556         DAM_PDCR5 = 0;
 557
 558         /* set to synchronous */
 559         DAM_PTCR1 |= AUDMUX_PTCR_SYN;
 560         DAM_PTCR5 |= AUDMUX_PTCR_SYN;
 561
 562 #if WM8350_SSI_MASTER
 563         /* set Rx sources 1 <--> 5 */
 564         DAM_PDCR1 |= AUDMUX_PDCR_RXDSEL(5);
 565         DAM_PDCR5 |= AUDMUX_PDCR_RXDSEL(1);
 566
 567         /* set Tx frame direction and source  5 --> 1 output */
 568         DAM_PTCR1 |= AUDMUX_PTCR_TFSDIR;
 569         DAM_PTCR1 |= AUDMUX_PTCR_TFSSEL(AUDMUX_FROM_TXFS, 5);
 570
 571         /* set Tx Clock direction and source 5--> 1 output */
 572         DAM_PTCR1 |= AUDMUX_PTCR_TCLKDIR;
 573         DAM_PTCR1 |= AUDMUX_PTCR_TCSEL(AUDMUX_FROM_TXFS, 5);
 574 #else
 575         /* set Rx sources 1 <--> 5 */
 576         DAM_PDCR1 |= AUDMUX_PDCR_RXDSEL(5);
 577         DAM_PDCR5 |= AUDMUX_PDCR_RXDSEL(1);
 578
 579         /* set Tx frame direction and source  1 --> 5 output */
 580         DAM_PTCR5 |= AUDMUX_PTCR_TFSDIR;
 581         DAM_PTCR5 |= AUDMUX_PTCR_TFSSEL(AUDMUX_FROM_TXFS, 1);
 582
 583         /* set Tx Clock direction and source 1--> 5 output */
 584         DAM_PTCR5 |= AUDMUX_PTCR_TCLKDIR;
 585         DAM_PTCR5 |= AUDMUX_PTCR_TCSEL(AUDMUX_FROM_TXFS, 1);
 586 #endif
 587         ret = snd_soc_card_register(soc_card);
 588         return ret;
 589
 590 err:
 591         snd_soc_card_free(soc_card);
 592 reg_err:
 593         regulator_put(audio_data->analog_supply);
 594 ssi_err:
 595         kfree(audio_data);
 596         put_ssi_clk(0);
 597         return ret;
 598 }
 599
 600 static int __devexit imx32ads_wm8350_audio_remove(struct platform_device *pdev)
 601 {
 602         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 603         struct snd_soc_card *soc_card = wm8350->audio;
 604         struct imx31ads_data *audio_data = soc_card->private_data;
 605
 606         wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
 607         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
 608         snd_soc_card_free(soc_card);
 609
 610         regulator_disable(audio_data->analog_supply);
 611         regulator_put(audio_data->analog_supply);
 612         kfree(audio_data);
 613         put_ssi_clk(0);
 614         return 0;
 615 }
 616
 617 static struct platform_driver imx32ads_wm8350_audio_driver = {
 618         .probe = imx32ads_wm8350_audio_probe,
 619         .remove = __devexit_p(imx32ads_wm8350_audio_remove),
 620         .suspend = imx32ads_wm8350_audio_suspend,
 621         .resume = imx32ads_wm8350_audio_resume,
 622         .driver = {
 623                    .name = "imx31ads-audio",
 624                    },
 625 };
 626
 627 static int __init imx32ads_wm8350_audio_init(void)
 628 {
 629         return platform_driver_register(&imx32ads_wm8350_audio_driver);
 630 }
 631
 632 static void __exit imx32ads_wm8350_audio_exit(void)
 633 {
 634         platform_driver_unregister(&imx32ads_wm8350_audio_driver);
 635 }
 636
 637 module_init(imx32ads_wm8350_audio_init);
 638 module_exit(imx32ads_wm8350_audio_exit);
 639
 640 MODULE_AUTHOR("Liam Girdwood");
 641 MODULE_DESCRIPTION("PMIC WM8350 Driver for i.MX32ADS");
 642 MODULE_LICENSE("GPL");