sound/soc/codecs/wm8753.c

   1 /*
   2  * wm8753.c  --  WM8753 ALSA Soc Audio driver
   3  *
   4  * Copyright 2003 Wolfson Microelectronics PLC.
   5  * Author: Liam Girdwood
   6  *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  * Notes:
  14  *  The WM8753 is a low power, high quality stereo codec with integrated PCM
  15  *  codec designed for portable digital telephony applications.
  16  *
  17  * Dual DAI:-
  18  *
  19  * This driver support 2 DAI PCM's. This makes the default PCM available for
  20  * HiFi audio (e.g. MP3, ogg) playback/capture and the other PCM available for
  21  * voice.
  22  *
  23  * Please note that the voice PCM can be connected directly to a Bluetooth
  24  * codec or GSM modem and thus cannot be read or written to, although it is
  25  * available to be configured with snd_hw_params(), etc and kcontrols in the
  26  * normal alsa manner.
  27  *
  28  * Fast DAI switching:-
  29  *
  30  * The driver can now fast switch between the DAI configurations via a
  31  * an alsa kcontrol. This allows the PCM to remain open.
  32  *
  33  */
  34
  35 #include <linux/module.h>
  36 #include <linux/moduleparam.h>
  37 #include <linux/version.h>
  38 #include <linux/kernel.h>
  39 #include <linux/init.h>
  40 #include <linux/delay.h>
  41 #include <linux/pm.h>
  42 #include <linux/i2c.h>
  43 #include <linux/platform_device.h>
  44 #include <sound/core.h>
  45 #include <sound/pcm.h>
  46 #include <sound/pcm_params.h>
  47 #include <sound/soc.h>
  48 #include <sound/soc-dapm.h>
  49 #include <sound/initval.h>
  50 #include <sound/tlv.h>
  51 #include <asm/div64.h>
  52
  53 #include "wm8753.h"
  54
  55 #define AUDIO_NAME "wm8753"
  56 #define WM8753_VERSION "0.16"
  57
  58 /*
  59  * Debug
  60  */
  61
  62 #define WM8753_DEBUG 0
  63
  64 #ifdef WM8753_DEBUG
  65 #define dbg(format, arg...) \
  66         printk(KERN_DEBUG AUDIO_NAME ": " format "\n" , ## arg)
  67 #else
  68 #define dbg(format, arg...) do {} while (0)
  69 #endif
  70 #define err(format, arg...) \
  71         printk(KERN_ERR AUDIO_NAME ": " format "\n" , ## arg)
  72 #define info(format, arg...) \
  73         printk(KERN_INFO AUDIO_NAME ": " format "\n" , ## arg)
  74 #define warn(format, arg...) \
  75         printk(KERN_WARNING AUDIO_NAME ": " format "\n" , ## arg)
  76
  77 static int caps_charge = 2000;
  78 module_param(caps_charge, int, 0);
  79 MODULE_PARM_DESC(caps_charge, "WM8753 cap charge time (msecs)");
  80
  81 static void wm8753_set_dai_mode(struct snd_soc_codec *codec,
  82         unsigned int mode);
  83
  84 /* codec private data */
  85 struct wm8753_priv {
  86         unsigned int sysclk;
  87         unsigned int pcmclk;
  88 };
  89
  90 /*
  91  * wm8753 register cache
  92  * We can't read the WM8753 register space when we
  93  * are using 2 wire for device control, so we cache them instead.
  94  */
  95 static const u16 wm8753_reg[] = {
  96         0x0008, 0x0000, 0x000a, 0x000a,
  97         0x0033, 0x0000, 0x0007, 0x00ff,
  98         0x00ff, 0x000f, 0x000f, 0x007b,
  99         0x0000, 0x0032, 0x0000, 0x00c3,
 100         0x00c3, 0x00c0, 0x0000, 0x0000,
 101         0x0000, 0x0000, 0x0000, 0x0000,
 102         0x0000, 0x0000, 0x0000, 0x0000,
 103         0x0000, 0x0000, 0x0000, 0x0055,
 104         0x0005, 0x0050, 0x0055, 0x0050,
 105         0x0055, 0x0050, 0x0055, 0x0079,
 106         0x0079, 0x0079, 0x0079, 0x0079,
 107         0x0000, 0x0000, 0x0000, 0x0000,
 108         0x0097, 0x0097, 0x0000, 0x0004,
 109         0x0000, 0x0083, 0x0024, 0x01ba,
 110         0x0000, 0x0083, 0x0024, 0x01ba,
 111         0x0000, 0x0000
 112 };
 113
 114 /*
 115  * read wm8753 register cache
 116  */
 117 static inline unsigned int wm8753_read_reg_cache(struct snd_soc_codec *codec,
 118         unsigned int reg)
 119 {
 120         u16 *cache = codec->reg_cache;
 121         if (reg < 1 || reg > (ARRAY_SIZE(wm8753_reg) + 1))
 122                 return -1;
 123         return cache[reg - 1];
 124 }
 125
 126 /*
 127  * write wm8753 register cache
 128  */
 129 static inline void wm8753_write_reg_cache(struct snd_soc_codec *codec,
 130         unsigned int reg, unsigned int value)
 131 {
 132         u16 *cache = codec->reg_cache;
 133         if (reg < 1 || reg > 0x3f)
 134                 return;
 135         cache[reg - 1] = value;
 136 }
 137
 138 /*
 139  * write to the WM8753 register space
 140  */
 141 static int wm8753_write(struct snd_soc_codec *codec, unsigned int reg,
 142         unsigned int value)
 143 {
 144         u8 data[2];
 145
 146         /* data is
 147          *   D15..D9 WM8753 register offset
 148          *   D8...D0 register data
 149          */
 150         data[0] = (reg << 1) | ((value >> 8) & 0x0001);
 151         data[1] = value & 0x00ff;
 152
 153         wm8753_write_reg_cache (codec, reg, value);
 154         if (codec->hw_write(codec->control_data, data, 2) == 2)
 155                 return 0;
 156         else
 157                 return -EIO;
 158 }
 159
 160 #define wm8753_reset(c) wm8753_write(c, WM8753_RESET, 0)
 161
 162 /*
 163  * WM8753 Controls
 164  */
 165 static const char *wm8753_base[] = {"Linear Control", "Adaptive Boost"};
 166 static const char *wm8753_base_filter[] =
 167         {"130Hz @ 48kHz", "200Hz @ 48kHz", "100Hz @ 16kHz", "400Hz @ 48kHz",
 168         "100Hz @ 8kHz", "200Hz @ 8kHz"};
 169 static const char *wm8753_treble[] = {"8kHz", "4kHz"};
 170 static const char *wm8753_alc_func[] = {"Off", "Right", "Left", "Stereo"};
 171 static const char *wm8753_ng_type[] = {"Constant PGA Gain", "Mute ADC Output"};
 172 static const char *wm8753_3d_func[] = {"Capture", "Playback"};
 173 static const char *wm8753_3d_uc[] = {"2.2kHz", "1.5kHz"};
 174 static const char *wm8753_3d_lc[] = {"200Hz", "500Hz"};
 175 static const char *wm8753_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz"};
 176 static const char *wm8753_mono_mix[] = {"Stereo", "Left", "Right", "Mono"};
 177 static const char *wm8753_dac_phase[] = {"Non Inverted", "Inverted"};
 178 static const char *wm8753_line_mix[] = {"Line 1 + 2", "Line 1 - 2",
 179         "Line 1", "Line 2"};
 180 static const char *wm8753_mono_mux[] = {"Line Mix", "Rx Mix"};
 181 static const char *wm8753_right_mux[] = {"Line 2", "Rx Mix"};
 182 static const char *wm8753_left_mux[] = {"Line 1", "Rx Mix"};
 183 static const char *wm8753_rxmsel[] = {"RXP - RXN", "RXP + RXN", "RXP", "RXN"};
 184 static const char *wm8753_sidetone_mux[] = {"Left PGA", "Mic 1", "Mic 2",
 185         "Right PGA"};
 186 static const char *wm8753_mono2_src[] = {"Inverted Mono 1", "Left", "Right",
 187         "Left + Right"};
 188 static const char *wm8753_out3[] = {"VREF", "ROUT2", "Left + Right"};
 189 static const char *wm8753_out4[] = {"VREF", "Capture ST", "LOUT2"};
 190 static const char *wm8753_radcsel[] = {"PGA", "Line or RXP-RXN", "Sidetone"};
 191 static const char *wm8753_ladcsel[] = {"PGA", "Line or RXP-RXN", "Line"};
 192 static const char *wm8753_mono_adc[] = {"Stereo", "Analogue Mix Left",
 193         "Analogue Mix Right", "Digital Mono Mix"};
 194 static const char *wm8753_adc_hp[] = {"3.4Hz @ 48kHz", "82Hz @ 16k",
 195         "82Hz @ 8kHz", "170Hz @ 8kHz"};
 196 static const char *wm8753_adc_filter[] = {"HiFi", "Voice"};
 197 static const char *wm8753_mic_sel[] = {"Mic 1", "Mic 2", "Mic 3"};
 198 static const char *wm8753_dai_mode[] = {"DAI 0", "DAI 1", "DAI 2", "DAI 3"};
 199 static const char *wm8753_dat_sel[] = {"Stereo", "Left ADC", "Right ADC",
 200         "Channel Swap"};
 201 static const char *wm8753_rout2_phase[] = {"Non Inverted", "Inverted"};
 202
 203 static const struct soc_enum wm8753_enum[] = {
 204 SOC_ENUM_SINGLE(WM8753_BASS, 7, 2, wm8753_base),
 205 SOC_ENUM_SINGLE(WM8753_BASS, 4, 6, wm8753_base_filter),
 206 SOC_ENUM_SINGLE(WM8753_TREBLE, 6, 2, wm8753_treble),
 207 SOC_ENUM_SINGLE(WM8753_ALC1, 7, 4, wm8753_alc_func),
 208 SOC_ENUM_SINGLE(WM8753_NGATE, 1, 2, wm8753_ng_type),
 209 SOC_ENUM_SINGLE(WM8753_3D, 7, 2, wm8753_3d_func),
 210 SOC_ENUM_SINGLE(WM8753_3D, 6, 2, wm8753_3d_uc),
 211 SOC_ENUM_SINGLE(WM8753_3D, 5, 2, wm8753_3d_lc),
 212 SOC_ENUM_SINGLE(WM8753_DAC, 1, 4, wm8753_deemp),
 213 SOC_ENUM_SINGLE(WM8753_DAC, 4, 4, wm8753_mono_mix),
 214 SOC_ENUM_SINGLE(WM8753_DAC, 6, 2, wm8753_dac_phase),
 215 SOC_ENUM_SINGLE(WM8753_INCTL1, 3, 4, wm8753_line_mix),
 216 SOC_ENUM_SINGLE(WM8753_INCTL1, 2, 2, wm8753_mono_mux),
 217 SOC_ENUM_SINGLE(WM8753_INCTL1, 1, 2, wm8753_right_mux),
 218 SOC_ENUM_SINGLE(WM8753_INCTL1, 0, 2, wm8753_left_mux),
 219 SOC_ENUM_SINGLE(WM8753_INCTL2, 6, 4, wm8753_rxmsel),
 220 SOC_ENUM_SINGLE(WM8753_INCTL2, 4, 4, wm8753_sidetone_mux),
 221 SOC_ENUM_SINGLE(WM8753_OUTCTL, 7, 4, wm8753_mono2_src),
 222 SOC_ENUM_SINGLE(WM8753_OUTCTL, 0, 3, wm8753_out3),
 223 SOC_ENUM_SINGLE(WM8753_ADCTL2, 7, 3, wm8753_out4),
 224 SOC_ENUM_SINGLE(WM8753_ADCIN, 2, 3, wm8753_radcsel),
 225 SOC_ENUM_SINGLE(WM8753_ADCIN, 0, 3, wm8753_ladcsel),
 226 SOC_ENUM_SINGLE(WM8753_ADCIN, 4, 4, wm8753_mono_adc),
 227 SOC_ENUM_SINGLE(WM8753_ADC, 2, 4, wm8753_adc_hp),
 228 SOC_ENUM_SINGLE(WM8753_ADC, 4, 2, wm8753_adc_filter),
 229 SOC_ENUM_SINGLE(WM8753_MICBIAS, 6, 3, wm8753_mic_sel),
 230 SOC_ENUM_SINGLE(WM8753_IOCTL, 2, 4, wm8753_dai_mode),
 231 SOC_ENUM_SINGLE(WM8753_ADC, 7, 4, wm8753_dat_sel),
 232 SOC_ENUM_SINGLE(WM8753_OUTCTL, 2, 2, wm8753_rout2_phase),
 233 };
 234
 235
 236 static int wm8753_get_dai(struct snd_kcontrol *kcontrol,
 237         struct snd_ctl_elem_value *ucontrol)
 238 {
 239         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
 240         int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
 241
 242         ucontrol->value.integer.value[0] = (mode & 0xc) >> 2;
 243         return 0;
 244 }
 245
 246 static int wm8753_set_dai(struct snd_kcontrol *kcontrol,
 247         struct snd_ctl_elem_value *ucontrol)
 248 {
 249         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
 250         int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
 251
 252         if (((mode &0xc) >> 2) == ucontrol->value.integer.value[0])
 253                 return 0;
 254
 255         mode &= 0xfff3;
 256         mode |= (ucontrol->value.integer.value[0] << 2);
 257
 258         wm8753_write(codec, WM8753_IOCTL, mode);
 259         wm8753_set_dai_mode(codec, ucontrol->value.integer.value[0]);
 260         return 1;
 261 }
 262
 263 static const DECLARE_TLV_DB_LINEAR(rec_mix_tlv, -1500, 600);
 264
 265 static const struct snd_kcontrol_new wm8753_snd_controls[] = {
 266 SOC_DOUBLE_R("PCM Volume", WM8753_LDAC, WM8753_RDAC, 0, 255, 0),
 267
 268 SOC_DOUBLE_R("ADC Capture Volume", WM8753_LADC, WM8753_RADC, 0, 255, 0),
 269
 270 SOC_DOUBLE_R("Headphone Playback Volume", WM8753_LOUT1V, WM8753_ROUT1V, 0, 127, 0),
 271 SOC_DOUBLE_R("Speaker Playback Volume", WM8753_LOUT2V, WM8753_ROUT2V, 0, 127, 0),
 272
 273 SOC_SINGLE("Mono Playback Volume", WM8753_MOUTV, 0, 127, 0),
 274
 275 SOC_DOUBLE_R("Bypass Playback Volume", WM8753_LOUTM1, WM8753_ROUTM1, 4, 7, 1),
 276 SOC_DOUBLE_R("Sidetone Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 4, 7, 1),
 277 SOC_DOUBLE_R("Voice Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 0, 7, 1),
 278
 279 SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8753_LOUT1V, WM8753_ROUT1V, 7, 1, 0),
 280 SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8753_LOUT2V, WM8753_ROUT2V, 7, 1, 0),
 281
 282 SOC_SINGLE("Mono Bypass Playback Volume", WM8753_MOUTM1, 4, 7, 1),
 283 SOC_SINGLE("Mono Sidetone Playback Volume", WM8753_MOUTM2, 4, 7, 1),
 284 SOC_SINGLE("Mono Voice Playback Volume", WM8753_MOUTM2, 0, 7, 1),
 285 SOC_SINGLE("Mono Playback ZC Switch", WM8753_MOUTV, 7, 1, 0),
 286
 287 SOC_ENUM("Bass Boost", wm8753_enum[0]),
 288 SOC_ENUM("Bass Filter", wm8753_enum[1]),
 289 SOC_SINGLE("Bass Volume", WM8753_BASS, 0, 15, 1),
 290
 291 SOC_SINGLE("Treble Volume", WM8753_TREBLE, 0, 15, 1),
 292 SOC_ENUM("Treble Cut-off", wm8753_enum[2]),
 293
 294 SOC_DOUBLE_TLV("Sidetone Capture Volume", WM8753_RECMIX1, 0, 4, 7, 1, rec_mix_tlv),
 295 SOC_SINGLE_TLV("Voice Sidetone Capture Volume", WM8753_RECMIX2, 0, 7, 1, rec_mix_tlv),
 296
 297 SOC_DOUBLE_R("Capture Volume", WM8753_LINVOL, WM8753_RINVOL, 0, 63, 0),
 298 SOC_DOUBLE_R("Capture ZC Switch", WM8753_LINVOL, WM8753_RINVOL, 6, 1, 0),
 299 SOC_DOUBLE_R("Capture Switch", WM8753_LINVOL, WM8753_RINVOL, 7, 1, 1),
 300
 301 SOC_ENUM("Capture Filter Select", wm8753_enum[23]),
 302 SOC_ENUM("Capture Filter Cut-off", wm8753_enum[24]),
 303 SOC_SINGLE("Capture Filter Switch", WM8753_ADC, 0, 1, 1),
 304
 305 SOC_SINGLE("ALC Capture Target Volume", WM8753_ALC1, 0, 7, 0),
 306 SOC_SINGLE("ALC Capture Max Volume", WM8753_ALC1, 4, 7, 0),
 307 SOC_ENUM("ALC Capture Function", wm8753_enum[3]),
 308 SOC_SINGLE("ALC Capture ZC Switch", WM8753_ALC2, 8, 1, 0),
 309 SOC_SINGLE("ALC Capture Hold Time", WM8753_ALC2, 0, 15, 1),
 310 SOC_SINGLE("ALC Capture Decay Time", WM8753_ALC3, 4, 15, 1),
 311 SOC_SINGLE("ALC Capture Attack Time", WM8753_ALC3, 0, 15, 0),
 312 SOC_SINGLE("ALC Capture NG Threshold", WM8753_NGATE, 3, 31, 0),
 313 SOC_ENUM("ALC Capture NG Type", wm8753_enum[4]),
 314 SOC_SINGLE("ALC Capture NG Switch", WM8753_NGATE, 0, 1, 0),
 315
 316 SOC_ENUM("3D Function", wm8753_enum[5]),
 317 SOC_ENUM("3D Upper Cut-off", wm8753_enum[6]),
 318 SOC_ENUM("3D Lower Cut-off", wm8753_enum[7]),
 319 SOC_SINGLE("3D Volume", WM8753_3D, 1, 15, 0),
 320 SOC_SINGLE("3D Switch", WM8753_3D, 0, 1, 0),
 321
 322 SOC_SINGLE("Capture 6dB Attenuate", WM8753_ADCTL1, 2, 1, 0),
 323 SOC_SINGLE("Playback 6dB Attenuate", WM8753_ADCTL1, 1, 1, 0),
 324
 325 SOC_ENUM("De-emphasis", wm8753_enum[8]),
 326 SOC_ENUM("Playback Mono Mix", wm8753_enum[9]),
 327 SOC_ENUM("Playback Phase", wm8753_enum[10]),
 328
 329 SOC_SINGLE("Mic2 Capture Volume", WM8753_INCTL1, 7, 3, 0),
 330 SOC_SINGLE("Mic1 Capture Volume", WM8753_INCTL1, 5, 3, 0),
 331
 332 SOC_ENUM_EXT("DAI Mode", wm8753_enum[26], wm8753_get_dai, wm8753_set_dai),
 333
 334 SOC_ENUM("ADC Data Select", wm8753_enum[27]),
 335 SOC_ENUM("ROUT2 Phase", wm8753_enum[28]),
 336 };
 337
 338 /* add non dapm controls */
 339 static int wm8753_add_controls(struct snd_soc_codec *codec)
 340 {
 341         int err, i;
 342
 343         for (i = 0; i < ARRAY_SIZE(wm8753_snd_controls); i++) {
 344                 err = snd_ctl_add(codec->card,
 345                                 snd_soc_cnew(&wm8753_snd_controls[i],codec, NULL));
 346                 if (err < 0)
 347                         return err;
 348         }
 349         return 0;
 350 }
 351
 352 /*
 353  * _DAPM_ Controls
 354  */
 355
 356 /* Left Mixer */
 357 static const struct snd_kcontrol_new wm8753_left_mixer_controls[] = {
 358 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_LOUTM2, 8, 1, 0),
 359 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_LOUTM2, 7, 1, 0),
 360 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_LOUTM1, 8, 1, 0),
 361 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_LOUTM1, 7, 1, 0),
 362 };
 363
 364 /* Right mixer */
 365 static const struct snd_kcontrol_new wm8753_right_mixer_controls[] = {
 366 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_ROUTM2, 8, 1, 0),
 367 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_ROUTM2, 7, 1, 0),
 368 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_ROUTM1, 8, 1, 0),
 369 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_ROUTM1, 7, 1, 0),
 370 };
 371
 372 /* Mono mixer */
 373 static const struct snd_kcontrol_new wm8753_mono_mixer_controls[] = {
 374 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_MOUTM1, 8, 1, 0),
 375 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_MOUTM2, 8, 1, 0),
 376 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_MOUTM2, 3, 1, 0),
 377 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_MOUTM2, 7, 1, 0),
 378 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_MOUTM1, 7, 1, 0),
 379 };
 380
 381 /* Mono 2 Mux */
 382 static const struct snd_kcontrol_new wm8753_mono2_controls =
 383 SOC_DAPM_ENUM("Route", wm8753_enum[17]);
 384
 385 /* Out 3 Mux */
 386 static const struct snd_kcontrol_new wm8753_out3_controls =
 387 SOC_DAPM_ENUM("Route", wm8753_enum[18]);
 388
 389 /* Out 4 Mux */
 390 static const struct snd_kcontrol_new wm8753_out4_controls =
 391 SOC_DAPM_ENUM("Route", wm8753_enum[19]);
 392
 393 /* ADC Mono Mix */
 394 static const struct snd_kcontrol_new wm8753_adc_mono_controls =
 395 SOC_DAPM_ENUM("Route", wm8753_enum[22]);
 396
 397 /* Record mixer */
 398 static const struct snd_kcontrol_new wm8753_record_mixer_controls[] = {
 399 SOC_DAPM_SINGLE("Voice Capture Switch", WM8753_RECMIX2, 3, 1, 0),
 400 SOC_DAPM_SINGLE("Left Capture Switch", WM8753_RECMIX1, 3, 1, 0),
 401 SOC_DAPM_SINGLE("Right Capture Switch", WM8753_RECMIX1, 7, 1, 0),
 402 };
 403
 404 /* Left ADC mux */
 405 static const struct snd_kcontrol_new wm8753_adc_left_controls =
 406 SOC_DAPM_ENUM("Route", wm8753_enum[21]);
 407
 408 /* Right ADC mux */
 409 static const struct snd_kcontrol_new wm8753_adc_right_controls =
 410 SOC_DAPM_ENUM("Route", wm8753_enum[20]);
 411
 412 /* MIC mux */
 413 static const struct snd_kcontrol_new wm8753_mic_mux_controls =
 414 SOC_DAPM_ENUM("Route", wm8753_enum[16]);
 415
 416 /* ALC mixer */
 417 static const struct snd_kcontrol_new wm8753_alc_mixer_controls[] = {
 418 SOC_DAPM_SINGLE("Line Capture Switch", WM8753_INCTL2, 3, 1, 0),
 419 SOC_DAPM_SINGLE("Mic2 Capture Switch", WM8753_INCTL2, 2, 1, 0),
 420 SOC_DAPM_SINGLE("Mic1 Capture Switch", WM8753_INCTL2, 1, 1, 0),
 421 SOC_DAPM_SINGLE("Rx Capture Switch", WM8753_INCTL2, 0, 1, 0),
 422 };
 423
 424 /* Left Line mux */
 425 static const struct snd_kcontrol_new wm8753_line_left_controls =
 426 SOC_DAPM_ENUM("Route", wm8753_enum[14]);
 427
 428 /* Right Line mux */
 429 static const struct snd_kcontrol_new wm8753_line_right_controls =
 430 SOC_DAPM_ENUM("Route", wm8753_enum[13]);
 431
 432 /* Mono Line mux */
 433 static const struct snd_kcontrol_new wm8753_line_mono_controls =
 434 SOC_DAPM_ENUM("Route", wm8753_enum[12]);
 435
 436 /* Line mux and mixer */
 437 static const struct snd_kcontrol_new wm8753_line_mux_mix_controls =
 438 SOC_DAPM_ENUM("Route", wm8753_enum[11]);
 439
 440 /* Rx mux and mixer */
 441 static const struct snd_kcontrol_new wm8753_rx_mux_mix_controls =
 442 SOC_DAPM_ENUM("Route", wm8753_enum[15]);
 443
 444 /* Mic Selector Mux */
 445 static const struct snd_kcontrol_new wm8753_mic_sel_mux_controls =
 446 SOC_DAPM_ENUM("Route", wm8753_enum[25]);
 447
 448 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
 449 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8753_PWR1, 5, 0),
 450 SND_SOC_DAPM_MIXER("Left Mixer", WM8753_PWR4, 0, 0,
 451         &wm8753_left_mixer_controls[0], ARRAY_SIZE(wm8753_left_mixer_controls)),
 452 SND_SOC_DAPM_PGA("Left Out 1", WM8753_PWR3, 8, 0, NULL, 0),
 453 SND_SOC_DAPM_PGA("Left Out 2", WM8753_PWR3, 6, 0, NULL, 0),
 454 SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback", WM8753_PWR1, 3, 0),
 455 SND_SOC_DAPM_OUTPUT("LOUT1"),
 456 SND_SOC_DAPM_OUTPUT("LOUT2"),
 457 SND_SOC_DAPM_MIXER("Right Mixer", WM8753_PWR4, 1, 0,
 458         &wm8753_right_mixer_controls[0], ARRAY_SIZE(wm8753_right_mixer_controls)),
 459 SND_SOC_DAPM_PGA("Right Out 1", WM8753_PWR3, 7, 0, NULL, 0),
 460 SND_SOC_DAPM_PGA("Right Out 2", WM8753_PWR3, 5, 0, NULL, 0),
 461 SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback", WM8753_PWR1, 2, 0),
 462 SND_SOC_DAPM_OUTPUT("ROUT1"),
 463 SND_SOC_DAPM_OUTPUT("ROUT2"),
 464 SND_SOC_DAPM_MIXER("Mono Mixer", WM8753_PWR4, 2, 0,
 465         &wm8753_mono_mixer_controls[0], ARRAY_SIZE(wm8753_mono_mixer_controls)),
 466 SND_SOC_DAPM_PGA("Mono Out 1", WM8753_PWR3, 2, 0, NULL, 0),
 467 SND_SOC_DAPM_PGA("Mono Out 2", WM8753_PWR3, 1, 0, NULL, 0),
 468 SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", WM8753_PWR1, 4, 0),
 469 SND_SOC_DAPM_OUTPUT("MONO1"),
 470 SND_SOC_DAPM_MUX("Mono 2 Mux", SND_SOC_NOPM, 0, 0, &wm8753_mono2_controls),
 471 SND_SOC_DAPM_OUTPUT("MONO2"),
 472 SND_SOC_DAPM_MIXER("Out3 Left + Right", -1, 0, 0, NULL, 0),
 473 SND_SOC_DAPM_MUX("Out3 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out3_controls),
 474 SND_SOC_DAPM_PGA("Out 3", WM8753_PWR3, 4, 0, NULL, 0),
 475 SND_SOC_DAPM_OUTPUT("OUT3"),
 476 SND_SOC_DAPM_MUX("Out4 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out4_controls),
 477 SND_SOC_DAPM_PGA("Out 4", WM8753_PWR3, 3, 0, NULL, 0),
 478 SND_SOC_DAPM_OUTPUT("OUT4"),
 479 SND_SOC_DAPM_MIXER("Playback Mixer", WM8753_PWR4, 3, 0,
 480         &wm8753_record_mixer_controls[0],
 481         ARRAY_SIZE(wm8753_record_mixer_controls)),
 482 SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8753_PWR2, 3, 0),
 483 SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8753_PWR2, 2, 0),
 484 SND_SOC_DAPM_MUX("Capture Left Mixer", SND_SOC_NOPM, 0, 0,
 485         &wm8753_adc_mono_controls),
 486 SND_SOC_DAPM_MUX("Capture Right Mixer", SND_SOC_NOPM, 0, 0,
 487         &wm8753_adc_mono_controls),
 488 SND_SOC_DAPM_MUX("Capture Left Mux", SND_SOC_NOPM, 0, 0,
 489         &wm8753_adc_left_controls),
 490 SND_SOC_DAPM_MUX("Capture Right Mux", SND_SOC_NOPM, 0, 0,
 491         &wm8753_adc_right_controls),
 492 SND_SOC_DAPM_MUX("Mic Sidetone Mux", SND_SOC_NOPM, 0, 0,
 493         &wm8753_mic_mux_controls),
 494 SND_SOC_DAPM_PGA("Left Capture Volume", WM8753_PWR2, 5, 0, NULL, 0),
 495 SND_SOC_DAPM_PGA("Right Capture Volume", WM8753_PWR2, 4, 0, NULL, 0),
 496 SND_SOC_DAPM_MIXER("ALC Mixer", WM8753_PWR2, 6, 0,
 497         &wm8753_alc_mixer_controls[0], ARRAY_SIZE(wm8753_alc_mixer_controls)),
 498 SND_SOC_DAPM_MUX("Line Left Mux", SND_SOC_NOPM, 0, 0,
 499         &wm8753_line_left_controls),
 500 SND_SOC_DAPM_MUX("Line Right Mux", SND_SOC_NOPM, 0, 0,
 501         &wm8753_line_right_controls),
 502 SND_SOC_DAPM_MUX("Line Mono Mux", SND_SOC_NOPM, 0, 0,
 503         &wm8753_line_mono_controls),
 504 SND_SOC_DAPM_MUX("Line Mixer", WM8753_PWR2, 0, 0,
 505         &wm8753_line_mux_mix_controls),
 506 SND_SOC_DAPM_MUX("Rx Mixer", WM8753_PWR2, 1, 0,
 507         &wm8753_rx_mux_mix_controls),
 508 SND_SOC_DAPM_PGA("Mic 1 Volume", WM8753_PWR2, 8, 0, NULL, 0),
 509 SND_SOC_DAPM_PGA("Mic 2 Volume", WM8753_PWR2, 7, 0, NULL, 0),
 510 SND_SOC_DAPM_MUX("Mic Selection Mux", SND_SOC_NOPM, 0, 0,
 511         &wm8753_mic_sel_mux_controls),
 512 SND_SOC_DAPM_INPUT("LINE1"),
 513 SND_SOC_DAPM_INPUT("LINE2"),
 514 SND_SOC_DAPM_INPUT("RXP"),
 515 SND_SOC_DAPM_INPUT("RXN"),
 516 SND_SOC_DAPM_INPUT("ACIN"),
 517 SND_SOC_DAPM_OUTPUT("ACOP"),
 518 SND_SOC_DAPM_INPUT("MIC1N"),
 519 SND_SOC_DAPM_INPUT("MIC1"),
 520 SND_SOC_DAPM_INPUT("MIC2N"),
 521 SND_SOC_DAPM_INPUT("MIC2"),
 522 SND_SOC_DAPM_VMID("VREF"),
 523 };
 524
 525 static const char *audio_map[][3] = {
 526         /* left mixer */
 527         {"Left Mixer", "Left Playback Switch", "Left DAC"},
 528         {"Left Mixer", "Voice Playback Switch", "Voice DAC"},
 529         {"Left Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 530         {"Left Mixer", "Bypass Playback Switch", "Line Left Mux"},
 531
 532         /* right mixer */
 533         {"Right Mixer", "Right Playback Switch", "Right DAC"},
 534         {"Right Mixer", "Voice Playback Switch", "Voice DAC"},
 535         {"Right Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 536         {"Right Mixer", "Bypass Playback Switch", "Line Right Mux"},
 537
 538         /* mono mixer */
 539         {"Mono Mixer", "Voice Playback Switch", "Voice DAC"},
 540         {"Mono Mixer", "Left Playback Switch", "Left DAC"},
 541         {"Mono Mixer", "Right Playback Switch", "Right DAC"},
 542         {"Mono Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 543         {"Mono Mixer", "Bypass Playback Switch", "Line Mono Mux"},
 544
 545         /* left out */
 546         {"Left Out 1", NULL, "Left Mixer"},
 547         {"Left Out 2", NULL, "Left Mixer"},
 548         {"LOUT1", NULL, "Left Out 1"},
 549         {"LOUT2", NULL, "Left Out 2"},
 550
 551         /* right out */
 552         {"Right Out 1", NULL, "Right Mixer"},
 553         {"Right Out 2", NULL, "Right Mixer"},
 554         {"ROUT1", NULL, "Right Out 1"},
 555         {"ROUT2", NULL, "Right Out 2"},
 556
 557         /* mono 1 out */
 558         {"Mono Out 1", NULL, "Mono Mixer"},
 559         {"MONO1", NULL, "Mono Out 1"},
 560
 561         /* mono 2 out */
 562         {"Mono 2 Mux", "Left + Right", "Out3 Left + Right"},
 563         {"Mono 2 Mux", "Inverted Mono 1", "MONO1"},
 564         {"Mono 2 Mux", "Left", "Left Mixer"},
 565         {"Mono 2 Mux", "Right", "Right Mixer"},
 566         {"Mono Out 2", NULL, "Mono 2 Mux"},
 567         {"MONO2", NULL, "Mono Out 2"},
 568
 569         /* out 3 */
 570         {"Out3 Left + Right", NULL, "Left Mixer"},
 571         {"Out3 Left + Right", NULL, "Right Mixer"},
 572         {"Out3 Mux", "VREF", "VREF"},
 573         {"Out3 Mux", "Left + Right", "Out3 Left + Right"},
 574         {"Out3 Mux", "ROUT2", "ROUT2"},
 575         {"Out 3", NULL, "Out3 Mux"},
 576         {"OUT3", NULL, "Out 3"},
 577
 578         /* out 4 */
 579         {"Out4 Mux", "VREF", "VREF"},
 580         {"Out4 Mux", "Capture ST", "Capture ST Mixer"},
 581         {"Out4 Mux", "LOUT2", "LOUT2"},
 582         {"Out 4", NULL, "Out4 Mux"},
 583         {"OUT4", NULL, "Out 4"},
 584
 585         /* record mixer  */
 586         {"Playback Mixer", "Left Capture Switch", "Left Mixer"},
 587         {"Playback Mixer", "Voice Capture Switch", "Mono Mixer"},
 588         {"Playback Mixer", "Right Capture Switch", "Right Mixer"},
 589
 590         /* Mic/SideTone Mux */
 591         {"Mic Sidetone Mux", "Left PGA", "Left Capture Volume"},
 592         {"Mic Sidetone Mux", "Right PGA", "Right Capture Volume"},
 593         {"Mic Sidetone Mux", "Mic 1", "Mic 1 Volume"},
 594         {"Mic Sidetone Mux", "Mic 2", "Mic 2 Volume"},
 595
 596         /* Capture Left Mux */
 597         {"Capture Left Mux", "PGA", "Left Capture Volume"},
 598         {"Capture Left Mux", "Line or RXP-RXN", "Line Left Mux"},
 599         {"Capture Left Mux", "Line", "LINE1"},
 600
 601         /* Capture Right Mux */
 602         {"Capture Right Mux", "PGA", "Right Capture Volume"},
 603         {"Capture Right Mux", "Line or RXP-RXN", "Line Right Mux"},
 604         {"Capture Right Mux", "Sidetone", "Capture ST Mixer"},
 605
 606         /* Mono Capture mixer-mux */
 607         {"Capture Right Mixer", "Stereo", "Capture Right Mux"},
 608         {"Capture Left Mixer", "Analogue Mix Left", "Capture Left Mux"},
 609         {"Capture Left Mixer", "Analogue Mix Left", "Capture Right Mux"},
 610         {"Capture Right Mixer", "Analogue Mix Right", "Capture Left Mux"},
 611         {"Capture Right Mixer", "Analogue Mix Right", "Capture Right Mux"},
 612         {"Capture Left Mixer", "Digital Mono Mix", "Capture Left Mux"},
 613         {"Capture Left Mixer", "Digital Mono Mix", "Capture Right Mux"},
 614         {"Capture Right Mixer", "Digital Mono Mix", "Capture Left Mux"},
 615         {"Capture Right Mixer", "Digital Mono Mix", "Capture Right Mux"},
 616
 617         /* ADC */
 618         {"Left ADC", NULL, "Capture Left Mixer"},
 619         {"Right ADC", NULL, "Capture Right Mixer"},
 620
 621         /* Left Capture Volume */
 622         {"Left Capture Volume", NULL, "ACIN"},
 623
 624         /* Right Capture Volume */
 625         {"Right Capture Volume", NULL, "Mic 2 Volume"},
 626
 627         /* ALC Mixer */
 628         {"ALC Mixer", "Line Capture Switch", "Line Mixer"},
 629         {"ALC Mixer", "Mic2 Capture Switch", "Mic 2 Volume"},
 630         {"ALC Mixer", "Mic1 Capture Switch", "Mic 1 Volume"},
 631         {"ALC Mixer", "Rx Capture Switch", "Rx Mixer"},
 632
 633         /* Line Left Mux */
 634         {"Line Left Mux", "Line 1", "LINE1"},
 635         {"Line Left Mux", "Rx Mix", "Rx Mixer"},
 636
 637         /* Line Right Mux */
 638         {"Line Right Mux", "Line 2", "LINE2"},
 639         {"Line Right Mux", "Rx Mix", "Rx Mixer"},
 640
 641         /* Line Mono Mux */
 642         {"Line Mono Mux", "Line Mix", "Line Mixer"},
 643         {"Line Mono Mux", "Rx Mix", "Rx Mixer"},
 644
 645         /* Line Mixer/Mux */
 646         {"Line Mixer", "Line 1 + 2", "LINE1"},
 647         {"Line Mixer", "Line 1 - 2", "LINE1"},
 648         {"Line Mixer", "Line 1 + 2", "LINE2"},
 649         {"Line Mixer", "Line 1 - 2", "LINE2"},
 650         {"Line Mixer", "Line 1", "LINE1"},
 651         {"Line Mixer", "Line 2", "LINE2"},
 652
 653         /* Rx Mixer/Mux */
 654         {"Rx Mixer", "RXP - RXN", "RXP"},
 655         {"Rx Mixer", "RXP + RXN", "RXP"},
 656         {"Rx Mixer", "RXP - RXN", "RXN"},
 657         {"Rx Mixer", "RXP + RXN", "RXN"},
 658         {"Rx Mixer", "RXP", "RXP"},
 659         {"Rx Mixer", "RXN", "RXN"},
 660
 661         /* Mic 1 Volume */
 662         {"Mic 1 Volume", NULL, "MIC1N"},
 663         {"Mic 1 Volume", NULL, "Mic Selection Mux"},
 664
 665         /* Mic 2 Volume */
 666         {"Mic 2 Volume", NULL, "MIC2N"},
 667         {"Mic 2 Volume", NULL, "MIC2"},
 668
 669         /* Mic Selector Mux */
 670         {"Mic Selection Mux", "Mic 1", "MIC1"},
 671         {"Mic Selection Mux", "Mic 2", "MIC2N"},
 672         {"Mic Selection Mux", "Mic 3", "MIC2"},
 673
 674         /* ACOP */
 675         {"ACOP", NULL, "ALC Mixer"},
 676
 677         /* terminator */
 678         {NULL, NULL, NULL},
 679 };
 680
 681 static int wm8753_add_widgets(struct snd_soc_codec *codec)
 682 {
 683         int i;
 684
 685         for (i = 0; i < ARRAY_SIZE(wm8753_dapm_widgets); i++)
 686                 snd_soc_dapm_new_control(codec, &wm8753_dapm_widgets[i]);
 687
 688         /* set up the WM8753 audio map */
 689         for (i = 0; audio_map[i][0] != NULL; i++) {
 690                 snd_soc_dapm_connect_input(codec, audio_map[i][0],
 691                         audio_map[i][1], audio_map[i][2]);
 692         }
 693
 694         snd_soc_dapm_new_widgets(codec);
 695         return 0;
 696 }
 697
 698 /* PLL divisors */
 699 struct _pll_div {
 700         u32 div2:1;
 701         u32 n:4;
 702         u32 k:24;
 703 };
 704
 705 /* The size in bits of the pll divide multiplied by 10
 706  * to allow rounding later */
 707 #define FIXED_PLL_SIZE ((1 << 22) * 10)
 708
 709 static void pll_factors(struct _pll_div *pll_div, unsigned int target,
 710         unsigned int source)
 711 {
 712         u64 Kpart;
 713         unsigned int K, Ndiv, Nmod;
 714
 715         Ndiv = target / source;
 716         if (Ndiv < 6) {
 717                 source >>= 1;
 718                 pll_div->div2 = 1;
 719                 Ndiv = target / source;
 720         } else
 721                 pll_div->div2 = 0;
 722
 723         if ((Ndiv < 6) || (Ndiv > 12))
 724                 printk(KERN_WARNING
 725                         "WM8753 N value outwith recommended range! N = %d\n",Ndiv);
 726
 727         pll_div->n = Ndiv;
 728         Nmod = target % source;
 729         Kpart = FIXED_PLL_SIZE * (long long)Nmod;
 730
 731         do_div(Kpart, source);
 732
 733         K = Kpart & 0xFFFFFFFF;
 734
 735         /* Check if we need to round */
 736         if ((K % 10) >= 5)
 737                 K += 5;
 738
 739         /* Move down to proper range now rounding is done */
 740         K /= 10;
 741
 742         pll_div->k = K;
 743 }
 744
 745 static int wm8753_set_dai_pll(struct snd_soc_codec_dai *codec_dai,
 746                 int pll_id, unsigned int freq_in, unsigned int freq_out)
 747 {
 748         u16 reg, enable;
 749         int offset;
 750         struct snd_soc_codec *codec = codec_dai->codec;
 751
 752         if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2)
 753                 return -ENODEV;
 754
 755         if (pll_id == WM8753_PLL1) {
 756                 offset = 0;
 757                 enable = 0x10;
 758                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xffef;
 759         } else {
 760                 offset = 4;
 761                 enable = 0x8;
 762                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfff7;
 763         }
 764
 765         if (!freq_in || !freq_out) {
 766                 /* disable PLL  */
 767                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0026);
 768                 wm8753_write(codec, WM8753_CLOCK, reg);
 769                 return 0;
 770         } else {
 771                 u16 value = 0;
 772                 struct _pll_div pll_div;
 773
 774                 pll_factors(&pll_div, freq_out * 8, freq_in);
 775
 776                 /* set up N and K PLL divisor ratios */
 777                 /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */
 778                 value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18);
 779                 wm8753_write(codec, WM8753_PLL1CTL2 + offset, value);
 780
 781                 /* bits 8:0 = PLL_K[17:9] */
 782                 value = (pll_div.k & 0x03fe00) >> 9;
 783                 wm8753_write(codec, WM8753_PLL1CTL3 + offset, value);
 784
 785                 /* bits 8:0 = PLL_K[8:0] */
 786                 value = pll_div.k & 0x0001ff;
 787                 wm8753_write(codec, WM8753_PLL1CTL4 + offset, value);
 788
 789                 /* set PLL as input and enable */
 790                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 |
 791                         (pll_div.div2 << 3));
 792                 wm8753_write(codec, WM8753_CLOCK, reg | enable);
 793         }
 794         return 0;
 795 }
 796
 797 struct _coeff_div {
 798         u32 mclk;
 799         u32 rate;
 800         u8 sr:5;
 801         u8 usb:1;
 802 };
 803
 804 /* codec hifi mclk (after PLL) clock divider coefficients */
 805 static const struct _coeff_div coeff_div[] = {
 806         /* 8k */
 807         {12288000, 8000, 0x6, 0x0},
 808         {11289600, 8000, 0x16, 0x0},
 809         {18432000, 8000, 0x7, 0x0},
 810         {16934400, 8000, 0x17, 0x0},
 811         {12000000, 8000, 0x6, 0x1},
 812
 813         /* 11.025k */
 814         {11289600, 11025, 0x18, 0x0},
 815         {16934400, 11025, 0x19, 0x0},
 816         {12000000, 11025, 0x19, 0x1},
 817
 818         /* 16k */
 819         {12288000, 16000, 0xa, 0x0},
 820         {18432000, 16000, 0xb, 0x0},
 821         {12000000, 16000, 0xa, 0x1},
 822
 823         /* 22.05k */
 824         {11289600, 22050, 0x1a, 0x0},
 825         {16934400, 22050, 0x1b, 0x0},
 826         {12000000, 22050, 0x1b, 0x1},
 827
 828         /* 32k */
 829         {12288000, 32000, 0xc, 0x0},
 830         {18432000, 32000, 0xd, 0x0},
 831         {12000000, 32000, 0xa, 0x1},
 832
 833         /* 44.1k */
 834         {11289600, 44100, 0x10, 0x0},
 835         {16934400, 44100, 0x11, 0x0},
 836         {12000000, 44100, 0x11, 0x1},
 837
 838         /* 48k */
 839         {12288000, 48000, 0x0, 0x0},
 840         {18432000, 48000, 0x1, 0x0},
 841         {12000000, 48000, 0x0, 0x1},
 842
 843         /* 88.2k */
 844         {11289600, 88200, 0x1e, 0x0},
 845         {16934400, 88200, 0x1f, 0x0},
 846         {12000000, 88200, 0x1f, 0x1},
 847
 848         /* 96k */
 849         {12288000, 96000, 0xe, 0x0},
 850         {18432000, 96000, 0xf, 0x0},
 851         {12000000, 96000, 0xe, 0x1},
 852 };
 853
 854 static int get_coeff(int mclk, int rate)
 855 {
 856         int i;
 857
 858         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
 859                 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
 860                         return i;
 861         }
 862         return -EINVAL;
 863 }
 864
 865 /*
 866  * Clock after PLL and dividers
 867  */
 868 static int wm8753_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai,
 869                 int clk_id, unsigned int freq, int dir)
 870 {
 871         struct snd_soc_codec *codec = codec_dai->codec;
 872         struct wm8753_priv *wm8753 = codec->private_data;
 873
 874         switch (freq) {
 875         case 11289600:
 876         case 12000000:
 877         case 12288000:
 878         case 16934400:
 879         case 18432000:
 880                 if (clk_id == WM8753_MCLK) {
 881                         wm8753->sysclk = freq;
 882                         return 0;
 883                 } else if (clk_id == WM8753_PCMCLK) {
 884                         wm8753->pcmclk = freq;
 885                         return 0;
 886                 }
 887                 break;
 888         }
 889         return -EINVAL;
 890 }
 891
 892 /*
 893  * Set's ADC and Voice DAC format.
 894  */
 895 static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 896                 unsigned int fmt)
 897 {
 898         struct snd_soc_codec *codec = codec_dai->codec;
 899         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01ec;
 900
 901         /* interface format */
 902         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 903         case SND_SOC_DAIFMT_I2S:
 904                 voice |= 0x0002;
 905                 break;
 906         case SND_SOC_DAIFMT_RIGHT_J:
 907                 break;
 908         case SND_SOC_DAIFMT_LEFT_J:
 909                 voice |= 0x0001;
 910                 break;
 911         case SND_SOC_DAIFMT_DSP_A:
 912                 voice |= 0x0003;
 913                 break;
 914         case SND_SOC_DAIFMT_DSP_B:
 915                 voice |= 0x0013;
 916                 break;
 917         default:
 918                 return -EINVAL;
 919         }
 920
 921         wm8753_write(codec, WM8753_PCM, voice);
 922         return 0;
 923 }
 924
 925 /*
 926  * Set PCM DAI bit size and sample rate.
 927  */
 928 static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream,
 929         struct snd_pcm_hw_params *params)
 930 {
 931         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 932         struct snd_soc_device *socdev = rtd->socdev;
 933         struct snd_soc_codec *codec = socdev->codec;
 934         struct wm8753_priv *wm8753 = codec->private_data;
 935         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01f3;
 936         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x017f;
 937
 938         /* bit size */
 939         switch (params_format(params)) {
 940         case SNDRV_PCM_FORMAT_S16_LE:
 941                 break;
 942         case SNDRV_PCM_FORMAT_S20_3LE:
 943                 voice |= 0x0004;
 944                 break;
 945         case SNDRV_PCM_FORMAT_S24_LE:
 946                 voice |= 0x0008;
 947                 break;
 948         case SNDRV_PCM_FORMAT_S32_LE:
 949                 voice |= 0x000c;
 950                 break;
 951         }
 952
 953         /* sample rate */
 954         if (params_rate(params) * 384 == wm8753->pcmclk)
 955                 srate |= 0x80;
 956         wm8753_write(codec, WM8753_SRATE1, srate);
 957
 958         wm8753_write(codec, WM8753_PCM, voice);
 959         return 0;
 960 }
 961
 962 /*
 963  * Set's PCM dai fmt and BCLK.
 964  */
 965 static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 966                 unsigned int fmt)
 967 {
 968         struct snd_soc_codec *codec = codec_dai->codec;
 969         u16 voice, ioctl;
 970
 971         voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x011f;
 972         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x015d;
 973
 974         /* set master/slave audio interface */
 975         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 976         case SND_SOC_DAIFMT_CBS_CFS:
 977                 break;
 978         case SND_SOC_DAIFMT_CBM_CFM:
 979                 ioctl |= 0x2;
 980         case SND_SOC_DAIFMT_CBM_CFS:
 981                 voice |= 0x0040;
 982                 break;
 983         default:
 984                 return -EINVAL;
 985         }
 986
 987         /* clock inversion */
 988         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 989         case SND_SOC_DAIFMT_DSP_A:
 990         case SND_SOC_DAIFMT_DSP_B:
 991                 /* frame inversion not valid for DSP modes */
 992                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 993                 case SND_SOC_DAIFMT_NB_NF:
 994                         break;
 995                 case SND_SOC_DAIFMT_IB_NF:
 996                         voice |= 0x0080;
 997                         break;
 998                 default:
 999                         return -EINVAL;
1000                 }
1001                 break;
1002         case SND_SOC_DAIFMT_I2S:
1003         case SND_SOC_DAIFMT_RIGHT_J:
1004         case SND_SOC_DAIFMT_LEFT_J:
1005                 voice &= ~0x0010;
1006                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1007                 case SND_SOC_DAIFMT_NB_NF:
1008                         break;
1009                 case SND_SOC_DAIFMT_IB_IF:
1010                         voice |= 0x0090;
1011                         break;
1012                 case SND_SOC_DAIFMT_IB_NF:
1013                         voice |= 0x0080;
1014                         break;
1015                 case SND_SOC_DAIFMT_NB_IF:
1016                         voice |= 0x0010;
1017                         break;
1018                 default:
1019                         return -EINVAL;
1020                 }
1021                 break;
1022         default:
1023                 return -EINVAL;
1024         }
1025
1026         wm8753_write(codec, WM8753_PCM, voice);
1027         wm8753_write(codec, WM8753_IOCTL, ioctl);
1028         return 0;
1029 }
1030
1031 static int wm8753_set_dai_clkdiv(struct snd_soc_codec_dai *codec_dai,
1032                 int div_id, int div)
1033 {
1034         struct snd_soc_codec *codec = codec_dai->codec;
1035         u16 reg;
1036
1037         switch (div_id) {
1038         case WM8753_PCMDIV:
1039                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0x003f;
1040                 wm8753_write(codec, WM8753_CLOCK, reg | div);
1041                 break;
1042         case WM8753_BCLKDIV:
1043                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x01c7;
1044                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1045                 break;
1046         case WM8753_VXCLKDIV:
1047                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x003f;
1048                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1049                 break;
1050         default:
1051                 return -EINVAL;
1052         }
1053         return 0;
1054 }
1055
1056 /*
1057  * Set's HiFi DAC format.
1058  */
1059 static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1060                 unsigned int fmt)
1061 {
1062         struct snd_soc_codec *codec = codec_dai->codec;
1063         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01e0;
1064
1065         /* interface format */
1066         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1067         case SND_SOC_DAIFMT_I2S:
1068                 hifi |= 0x0002;
1069                 break;
1070         case SND_SOC_DAIFMT_RIGHT_J:
1071                 break;
1072         case SND_SOC_DAIFMT_LEFT_J:
1073                 hifi |= 0x0001;
1074                 break;
1075         case SND_SOC_DAIFMT_DSP_A:
1076                 hifi |= 0x0003;
1077                 break;
1078         case SND_SOC_DAIFMT_DSP_B:
1079                 hifi |= 0x0013;
1080                 break;
1081         default:
1082                 return -EINVAL;
1083         }
1084
1085         wm8753_write(codec, WM8753_HIFI, hifi);
1086         return 0;
1087 }
1088
1089 /*
1090  * Set's I2S DAI format.
1091  */
1092 static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1093                 unsigned int fmt)
1094 {
1095         struct snd_soc_codec *codec = codec_dai->codec;
1096         u16 ioctl, hifi;
1097
1098         hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x011f;
1099         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x00ae;
1100
1101         /* set master/slave audio interface */
1102         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1103         case SND_SOC_DAIFMT_CBS_CFS:
1104                 break;
1105         case SND_SOC_DAIFMT_CBM_CFM:
1106                 ioctl |= 0x1;
1107         case SND_SOC_DAIFMT_CBM_CFS:
1108                 hifi |= 0x0040;
1109                 break;
1110         default:
1111                 return -EINVAL;
1112         }
1113
1114         /* clock inversion */
1115         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1116         case SND_SOC_DAIFMT_DSP_A:
1117         case SND_SOC_DAIFMT_DSP_B:
1118                 /* frame inversion not valid for DSP modes */
1119                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1120                 case SND_SOC_DAIFMT_NB_NF:
1121                         break;
1122                 case SND_SOC_DAIFMT_IB_NF:
1123                         hifi |= 0x0080;
1124                         break;
1125                 default:
1126                         return -EINVAL;
1127                 }
1128                 break;
1129         case SND_SOC_DAIFMT_I2S:
1130         case SND_SOC_DAIFMT_RIGHT_J:
1131         case SND_SOC_DAIFMT_LEFT_J:
1132                 hifi &= ~0x0010;
1133                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1134                 case SND_SOC_DAIFMT_NB_NF:
1135                         break;
1136                 case SND_SOC_DAIFMT_IB_IF:
1137                         hifi |= 0x0090;
1138                         break;
1139                 case SND_SOC_DAIFMT_IB_NF:
1140                         hifi |= 0x0080;
1141                         break;
1142                 case SND_SOC_DAIFMT_NB_IF:
1143                         hifi |= 0x0010;
1144                         break;
1145                 default:
1146                         return -EINVAL;
1147                 }
1148                 break;
1149         default:
1150                 return -EINVAL;
1151         }
1152
1153         wm8753_write(codec, WM8753_HIFI, hifi);
1154         wm8753_write(codec, WM8753_IOCTL, ioctl);
1155         return 0;
1156 }
1157
1158 /*
1159  * Set PCM DAI bit size and sample rate.
1160  */
1161 static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream,
1162         struct snd_pcm_hw_params *params)
1163 {
1164         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1165         struct snd_soc_device *socdev = rtd->socdev;
1166         struct snd_soc_codec *codec = socdev->codec;
1167         struct wm8753_priv *wm8753 = codec->private_data;
1168         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x01c0;
1169         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01f3;
1170         int coeff;
1171
1172         /* is digital filter coefficient valid ? */
1173         coeff = get_coeff(wm8753->sysclk, params_rate(params));
1174         if (coeff < 0) {
1175                 printk(KERN_ERR "wm8753 invalid MCLK or rate\n");
1176                 return coeff;
1177         }
1178         wm8753_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) |
1179                 coeff_div[coeff].usb);
1180
1181         /* bit size */
1182         switch (params_format(params)) {
1183         case SNDRV_PCM_FORMAT_S16_LE:
1184                 break;
1185         case SNDRV_PCM_FORMAT_S20_3LE:
1186                 hifi |= 0x0004;
1187                 break;
1188         case SNDRV_PCM_FORMAT_S24_LE:
1189                 hifi |= 0x0008;
1190                 break;
1191         case SNDRV_PCM_FORMAT_S32_LE:
1192                 hifi |= 0x000c;
1193                 break;
1194         }
1195
1196         wm8753_write(codec, WM8753_HIFI, hifi);
1197         return 0;
1198 }
1199
1200 static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1201                 unsigned int fmt)
1202 {
1203         struct snd_soc_codec *codec = codec_dai->codec;
1204         u16 clock;
1205
1206         /* set clk source as pcmclk */
1207         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1208         wm8753_write(codec, WM8753_CLOCK, clock);
1209
1210         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1211                 return -EINVAL;
1212         return wm8753_pcm_set_dai_fmt(codec_dai, fmt);
1213 }
1214
1215 static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1216                 unsigned int fmt)
1217 {
1218         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1219                 return -EINVAL;
1220         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1221 }
1222
1223 static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1224                 unsigned int fmt)
1225 {
1226         struct snd_soc_codec *codec = codec_dai->codec;
1227         u16 clock;
1228
1229         /* set clk source as pcmclk */
1230         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1231         wm8753_write(codec, WM8753_CLOCK, clock);
1232
1233         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1234                 return -EINVAL;
1235         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1236 }
1237
1238 static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1239                 unsigned int fmt)
1240 {
1241         struct snd_soc_codec *codec = codec_dai->codec;
1242         u16 clock;
1243
1244         /* set clk source as mclk */
1245         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1246         wm8753_write(codec, WM8753_CLOCK, clock | 0x4);
1247
1248         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1249                 return -EINVAL;
1250         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1251                 return -EINVAL;
1252         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1253 }
1254
1255 static int wm8753_mute(struct snd_soc_codec_dai *dai, int mute)
1256 {
1257         struct snd_soc_codec *codec = dai->codec;
1258         u16 mute_reg = wm8753_read_reg_cache(codec, WM8753_DAC) & 0xfff7;
1259
1260         /* the digital mute covers the HiFi and Voice DAC's on the WM8753.
1261          * make sure we check if they are not both active when we mute */
1262         if (mute && dai->id == 1) {
1263                 if (!wm8753_dai[WM8753_DAI_VOICE].playback.active ||
1264                         !wm8753_dai[WM8753_DAI_HIFI].playback.active)
1265                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1266         } else {
1267                 if (mute)
1268                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1269                 else
1270                         wm8753_write(codec, WM8753_DAC, mute_reg);
1271         }
1272
1273         return 0;
1274 }
1275
1276 static int wm8753_dapm_event(struct snd_soc_codec *codec, int event)
1277 {
1278         u16 pwr_reg = wm8753_read_reg_cache(codec, WM8753_PWR1) & 0xfe3e;
1279
1280         switch (event) {
1281         case SNDRV_CTL_POWER_D0: /* full On */
1282                 /* set vmid to 50k and unmute dac */
1283                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
1284                 break;
1285         case SNDRV_CTL_POWER_D1: /* partial On */
1286         case SNDRV_CTL_POWER_D2: /* partial On */
1287                 /* set vmid to 5k for quick power up */
1288                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
1289                 break;
1290         case SNDRV_CTL_POWER_D3hot: /* Off, with power */
1291                 /* mute dac and set vmid to 500k, enable VREF */
1292                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
1293                 break;
1294         case SNDRV_CTL_POWER_D3cold: /* Off, without power */
1295                 wm8753_write(codec, WM8753_PWR1, 0x0001);
1296                 break;
1297         }
1298         codec->dapm_state = event;
1299         return 0;
1300 }
1301
1302 #define WM8753_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
1303                 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_44100 | \
1304                 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
1305
1306 #define WM8753_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1307         SNDRV_PCM_FMTBIT_S24_LE)
1308
1309 /*
1310  * The WM8753 supports upto 4 different and mutually exclusive DAI
1311  * configurations. This gives 2 PCM's available for use, hifi and voice.
1312  * NOTE: The Voice PCM cannot play or capture audio to the CPU as it's DAI
1313  * is connected between the wm8753 and a BT codec or GSM modem.
1314  *
1315  * 1. Voice over PCM DAI - HIFI DAC over HIFI DAI
1316  * 2. Voice over HIFI DAI - HIFI disabled
1317  * 3. Voice disabled - HIFI over HIFI
1318  * 4. Voice disabled - HIFI over HIFI, uses voice DAI LRC for capture
1319  */
1320 static const struct snd_soc_codec_dai wm8753_all_dai[] = {
1321 /* DAI HiFi mode 1 */
1322 {       .name = "WM8753 HiFi",
1323         .id = 1,
1324         .playback = {
1325                 .stream_name = "HiFi Playback",
1326                 .channels_min = 1,
1327                 .channels_max = 2,
1328                 .rates = WM8753_RATES,
1329                 .formats = WM8753_FORMATS,},
1330         .capture = { /* dummy for fast DAI switching */
1331                 .stream_name = "Capture",
1332                 .channels_min = 1,
1333                 .channels_max = 2,
1334                 .rates = WM8753_RATES,
1335                 .formats = WM8753_FORMATS,},
1336         .ops = {
1337                 .hw_params = wm8753_i2s_hw_params,},
1338         .dai_ops = {
1339                 .digital_mute = wm8753_mute,
1340                 .set_fmt = wm8753_mode1h_set_dai_fmt,
1341                 .set_clkdiv = wm8753_set_dai_clkdiv,
1342                 .set_pll = wm8753_set_dai_pll,
1343                 .set_sysclk = wm8753_set_dai_sysclk,
1344         },
1345 },
1346 /* DAI Voice mode 1 */
1347 {       .name = "WM8753 Voice",
1348         .id = 1,
1349         .playback = {
1350                 .stream_name = "Voice Playback",
1351                 .channels_min = 1,
1352                 .channels_max = 1,
1353                 .rates = WM8753_RATES,
1354                 .formats = WM8753_FORMATS,},
1355         .capture = {
1356                 .stream_name = "Capture",
1357                 .channels_min = 1,
1358                 .channels_max = 2,
1359                 .rates = WM8753_RATES,
1360                 .formats = WM8753_FORMATS,},
1361         .ops = {
1362                 .hw_params = wm8753_pcm_hw_params,},
1363         .dai_ops = {
1364                 .digital_mute = wm8753_mute,
1365                 .set_fmt = wm8753_mode1v_set_dai_fmt,
1366                 .set_clkdiv = wm8753_set_dai_clkdiv,
1367                 .set_pll = wm8753_set_dai_pll,
1368                 .set_sysclk = wm8753_set_dai_sysclk,
1369         },
1370 },
1371 /* DAI HiFi mode 2 - dummy */
1372 {       .name = "WM8753 HiFi",
1373         .id = 2,
1374 },
1375 /* DAI Voice mode 2 */
1376 {       .name = "WM8753 Voice",
1377         .id = 2,
1378         .playback = {
1379                 .stream_name = "Voice Playback",
1380                 .channels_min = 1,
1381                 .channels_max = 1,
1382                 .rates = WM8753_RATES,
1383                 .formats = WM8753_FORMATS,},
1384         .capture = {
1385                 .stream_name = "Capture",
1386                 .channels_min = 1,
1387                 .channels_max = 2,
1388                 .rates = WM8753_RATES,
1389                 .formats = WM8753_FORMATS,},
1390         .ops = {
1391                 .hw_params = wm8753_pcm_hw_params,},
1392         .dai_ops = {
1393                 .digital_mute = wm8753_mute,
1394                 .set_fmt = wm8753_mode2_set_dai_fmt,
1395                 .set_clkdiv = wm8753_set_dai_clkdiv,
1396                 .set_pll = wm8753_set_dai_pll,
1397                 .set_sysclk = wm8753_set_dai_sysclk,
1398         },
1399 },
1400 /* DAI HiFi mode 3 */
1401 {       .name = "WM8753 HiFi",
1402         .id = 3,
1403         .playback = {
1404                 .stream_name = "HiFi Playback",
1405                 .channels_min = 1,
1406                 .channels_max = 2,
1407                 .rates = WM8753_RATES,
1408                 .formats = WM8753_FORMATS,},
1409         .capture = {
1410                 .stream_name = "Capture",
1411                 .channels_min = 1,
1412                 .channels_max = 2,
1413                 .rates = WM8753_RATES,
1414                 .formats = WM8753_FORMATS,},
1415         .ops = {
1416                 .hw_params = wm8753_i2s_hw_params,},
1417         .dai_ops = {
1418                 .digital_mute = wm8753_mute,
1419                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1420                 .set_clkdiv = wm8753_set_dai_clkdiv,
1421                 .set_pll = wm8753_set_dai_pll,
1422                 .set_sysclk = wm8753_set_dai_sysclk,
1423         },
1424 },
1425 /* DAI Voice mode 3 - dummy */
1426 {       .name = "WM8753 Voice",
1427         .id = 3,
1428 },
1429 /* DAI HiFi mode 4 */
1430 {       .name = "WM8753 HiFi",
1431         .id = 4,
1432         .playback = {
1433                 .stream_name = "HiFi Playback",
1434                 .channels_min = 1,
1435                 .channels_max = 2,
1436                 .rates = WM8753_RATES,
1437                 .formats = WM8753_FORMATS,},
1438         .capture = {
1439                 .stream_name = "Capture",
1440                 .channels_min = 1,
1441                 .channels_max = 2,
1442                 .rates = WM8753_RATES,
1443                 .formats = WM8753_FORMATS,},
1444         .ops = {
1445                 .hw_params = wm8753_i2s_hw_params,},
1446         .dai_ops = {
1447                 .digital_mute = wm8753_mute,
1448                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1449                 .set_clkdiv = wm8753_set_dai_clkdiv,
1450                 .set_pll = wm8753_set_dai_pll,
1451                 .set_sysclk = wm8753_set_dai_sysclk,
1452         },
1453 },
1454 /* DAI Voice mode 4 - dummy */
1455 {       .name = "WM8753 Voice",
1456         .id = 4,
1457 },
1458 };
1459
1460 struct snd_soc_codec_dai wm8753_dai[2];
1461 EXPORT_SYMBOL_GPL(wm8753_dai);
1462
1463 static void wm8753_set_dai_mode(struct snd_soc_codec *codec, unsigned int mode)
1464 {
1465         if (mode < 4) {
1466                 int playback_active, capture_active, codec_active, pop_wait;
1467                 void *private_data;
1468
1469                 playback_active = wm8753_dai[0].playback.active;
1470                 capture_active = wm8753_dai[0].capture.active;
1471                 codec_active = wm8753_dai[0].active;
1472                 private_data = wm8753_dai[0].private_data;
1473                 pop_wait = wm8753_dai[0].pop_wait;
1474                 wm8753_dai[0] = wm8753_all_dai[mode << 1];
1475                 wm8753_dai[0].playback.active = playback_active;
1476                 wm8753_dai[0].capture.active = capture_active;
1477                 wm8753_dai[0].active = codec_active;
1478                 wm8753_dai[0].private_data = private_data;
1479                 wm8753_dai[0].pop_wait = pop_wait;
1480
1481                 playback_active = wm8753_dai[1].playback.active;
1482                 capture_active = wm8753_dai[1].capture.active;
1483                 codec_active = wm8753_dai[1].active;
1484                 private_data = wm8753_dai[1].private_data;
1485                 pop_wait = wm8753_dai[1].pop_wait;
1486                 wm8753_dai[1] = wm8753_all_dai[(mode << 1) + 1];
1487                 wm8753_dai[1].playback.active = playback_active;
1488                 wm8753_dai[1].capture.active = capture_active;
1489                 wm8753_dai[1].active = codec_active;
1490                 wm8753_dai[1].private_data = private_data;
1491                 wm8753_dai[1].pop_wait = pop_wait;
1492         }
1493         wm8753_dai[0].codec = codec;
1494         wm8753_dai[1].codec = codec;
1495 }
1496
1497 static void wm8753_work(struct work_struct *work)
1498 {
1499         struct snd_soc_codec *codec =
1500                 container_of(work, struct snd_soc_codec, delayed_work.work);
1501         wm8753_dapm_event(codec, codec->dapm_state);
1502 }
1503
1504 static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
1505 {
1506         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1507         struct snd_soc_codec *codec = socdev->codec;
1508
1509         /* we only need to suspend if we are a valid card */
1510         if(!codec->card)
1511                 return 0;
1512
1513         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1514         return 0;
1515 }
1516
1517 static int wm8753_resume(struct platform_device *pdev)
1518 {
1519         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1520         struct snd_soc_codec *codec = socdev->codec;
1521         int i;
1522         u8 data[2];
1523         u16 *cache = codec->reg_cache;
1524
1525         /* we only need to resume if we are a valid card */
1526         if(!codec->card)
1527                 return 0;
1528
1529         /* Sync reg_cache with the hardware */
1530         for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
1531                 if (i + 1 == WM8753_RESET)
1532                         continue;
1533                 data[0] = ((i + 1) << 1) | ((cache[i] >> 8) & 0x0001);
1534                 data[1] = cache[i] & 0x00ff;
1535                 codec->hw_write(codec->control_data, data, 2);
1536         }
1537
1538         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3hot);
1539
1540         /* charge wm8753 caps */
1541         if (codec->suspend_dapm_state == SNDRV_CTL_POWER_D0) {
1542                 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1543                 codec->dapm_state = SNDRV_CTL_POWER_D0;
1544                 schedule_delayed_work(&codec->delayed_work,
1545                         msecs_to_jiffies(caps_charge));
1546         }
1547
1548         return 0;
1549 }
1550
1551 /*
1552  * initialise the WM8753 driver
1553  * register the mixer and dsp interfaces with the kernel
1554  */
1555 static int wm8753_init(struct snd_soc_device *socdev)
1556 {
1557         struct snd_soc_codec *codec = socdev->codec;
1558         int reg, ret = 0;
1559
1560         codec->name = "WM8753";
1561         codec->owner = THIS_MODULE;
1562         codec->read = wm8753_read_reg_cache;
1563         codec->write = wm8753_write;
1564         codec->dapm_event = wm8753_dapm_event;
1565         codec->dai = wm8753_dai;
1566         codec->num_dai = 2;
1567         codec->reg_cache_size = sizeof(wm8753_reg);
1568         codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
1569
1570         if (codec->reg_cache == NULL)
1571                 return -ENOMEM;
1572
1573         wm8753_set_dai_mode(codec, 0);
1574
1575         wm8753_reset(codec);
1576
1577         /* register pcms */
1578         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
1579         if (ret < 0) {
1580                 printk(KERN_ERR "wm8753: failed to create pcms\n");
1581                 goto pcm_err;
1582         }
1583
1584         /* charge output caps */
1585         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1586         codec->dapm_state = SNDRV_CTL_POWER_D3hot;
1587         schedule_delayed_work(&codec->delayed_work,
1588                 msecs_to_jiffies(caps_charge));
1589
1590         /* set the update bits */
1591         reg = wm8753_read_reg_cache(codec, WM8753_LDAC);
1592         wm8753_write(codec, WM8753_LDAC, reg | 0x0100);
1593         reg = wm8753_read_reg_cache(codec, WM8753_RDAC);
1594         wm8753_write(codec, WM8753_RDAC, reg | 0x0100);
1595         reg = wm8753_read_reg_cache(codec, WM8753_LADC);
1596         wm8753_write(codec, WM8753_LADC, reg | 0x0100);
1597         reg = wm8753_read_reg_cache(codec, WM8753_RADC);
1598         wm8753_write(codec, WM8753_RADC, reg | 0x0100);
1599         reg = wm8753_read_reg_cache(codec, WM8753_LOUT1V);
1600         wm8753_write(codec, WM8753_LOUT1V, reg | 0x0100);
1601         reg = wm8753_read_reg_cache(codec, WM8753_ROUT1V);
1602         wm8753_write(codec, WM8753_ROUT1V, reg | 0x0100);
1603         reg = wm8753_read_reg_cache(codec, WM8753_LOUT2V);
1604         wm8753_write(codec, WM8753_LOUT2V, reg | 0x0100);
1605         reg = wm8753_read_reg_cache(codec, WM8753_ROUT2V);
1606         wm8753_write(codec, WM8753_ROUT2V, reg | 0x0100);
1607         reg = wm8753_read_reg_cache(codec, WM8753_LINVOL);
1608         wm8753_write(codec, WM8753_LINVOL, reg | 0x0100);
1609         reg = wm8753_read_reg_cache(codec, WM8753_RINVOL);
1610         wm8753_write(codec, WM8753_RINVOL, reg | 0x0100);
1611
1612         wm8753_add_controls(codec);
1613         wm8753_add_widgets(codec);
1614         ret = snd_soc_register_card(socdev);
1615         if (ret < 0) {
1616         printk(KERN_ERR "wm8753: failed to register card\n");
1617                 goto card_err;
1618     }
1619         return ret;
1620
1621 card_err:
1622         snd_soc_free_pcms(socdev);
1623         snd_soc_dapm_free(socdev);
1624 pcm_err:
1625         kfree(codec->reg_cache);
1626         return ret;
1627 }
1628
1629 /* If the i2c layer weren't so broken, we could pass this kind of data
1630    around */
1631 static struct snd_soc_device *wm8753_socdev;
1632
1633 #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE)
1634
1635 /*
1636  * WM8753 2 wire address is determined by GPIO5
1637  * state during powerup.
1638  *    low  = 0x1a
1639  *    high = 0x1b
1640  */
1641 static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END };
1642
1643 /* Magic definition of all other variables and things */
1644 I2C_CLIENT_INSMOD;
1645
1646 static struct i2c_driver wm8753_i2c_driver;
1647 static struct i2c_client client_template;
1648
1649 static int wm8753_codec_probe(struct i2c_adapter *adap, int addr, int kind)
1650 {
1651         struct snd_soc_device *socdev = wm8753_socdev;
1652         struct wm8753_setup_data *setup = socdev->codec_data;
1653         struct snd_soc_codec *codec = socdev->codec;
1654         struct i2c_client *i2c;
1655         int ret;
1656
1657         if (addr != setup->i2c_address)
1658                 return -ENODEV;
1659
1660         client_template.adapter = adap;
1661         client_template.addr = addr;
1662
1663         i2c =  kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
1664         if (i2c == NULL){
1665                 kfree(codec);
1666                 return -ENOMEM;
1667         }
1668         i2c_set_clientdata(i2c, codec);
1669         codec->control_data = i2c;
1670
1671         ret = i2c_attach_client(i2c);
1672         if (ret < 0) {
1673                 err("failed to attach codec at addr %x\n", addr);
1674                 goto err;
1675         }
1676
1677         ret = wm8753_init(socdev);
1678         if (ret < 0) {
1679                 err("failed to initialise WM8753\n");
1680                 goto err;
1681         }
1682
1683         return ret;
1684
1685 err:
1686         kfree(codec);
1687         kfree(i2c);
1688         return ret;
1689 }
1690
1691 static int wm8753_i2c_detach(struct i2c_client *client)
1692 {
1693         struct snd_soc_codec *codec = i2c_get_clientdata(client);
1694         i2c_detach_client(client);
1695         kfree(codec->reg_cache);
1696         kfree(client);
1697         return 0;
1698 }
1699
1700 static int wm8753_i2c_attach(struct i2c_adapter *adap)
1701 {
1702         return i2c_probe(adap, &addr_data, wm8753_codec_probe);
1703 }
1704
1705 /* corgi i2c codec control layer */
1706 static struct i2c_driver wm8753_i2c_driver = {
1707         .driver = {
1708                 .name = "WM8753 I2C Codec",
1709                 .owner = THIS_MODULE,
1710         },
1711         .id =             I2C_DRIVERID_WM8753,
1712         .attach_adapter = wm8753_i2c_attach,
1713         .detach_client =  wm8753_i2c_detach,
1714         .command =        NULL,
1715 };
1716
1717 static struct i2c_client client_template = {
1718         .name =   "WM8753",
1719         .driver = &wm8753_i2c_driver,
1720 };
1721 #endif
1722
1723 static int wm8753_probe(struct platform_device *pdev)
1724 {
1725         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1726         struct wm8753_setup_data *setup;
1727         struct snd_soc_codec *codec;
1728         struct wm8753_priv *wm8753;
1729         int ret = 0;
1730
1731         info("WM8753 Audio Codec %s", WM8753_VERSION);
1732
1733         setup = socdev->codec_data;
1734         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
1735         if (codec == NULL)
1736                 return -ENOMEM;
1737
1738         wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
1739         if (wm8753 == NULL) {
1740                 kfree(codec);
1741                 return -ENOMEM;
1742         }
1743
1744         codec->private_data = wm8753;
1745         socdev->codec = codec;
1746         mutex_init(&codec->mutex);
1747         INIT_LIST_HEAD(&codec->dapm_widgets);
1748         INIT_LIST_HEAD(&codec->dapm_paths);
1749         wm8753_socdev = socdev;
1750         INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
1751
1752 #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE)
1753         if (setup->i2c_address) {
1754                 normal_i2c[0] = setup->i2c_address;
1755                 codec->hw_write = (hw_write_t)i2c_master_send;
1756                 ret = i2c_add_driver(&wm8753_i2c_driver);
1757                 if (ret != 0)
1758                         printk(KERN_ERR "can't add i2c driver");
1759         }
1760 #else
1761                 /* Add other interfaces here */
1762 #endif
1763         return ret;
1764 }
1765
1766 /*
1767  * This function forces any delayed work to be queued and run.
1768  */
1769 static int run_delayed_work(struct delayed_work *dwork)
1770 {
1771         int ret;
1772
1773         /* cancel any work waiting to be queued. */
1774         ret = cancel_delayed_work(dwork);
1775
1776         /* if there was any work waiting then we run it now and
1777          * wait for it's completion */
1778         if (ret) {
1779                 schedule_delayed_work(dwork, 0);
1780                 flush_scheduled_work();
1781         }
1782         return ret;
1783 }
1784
1785 /* power down chip */
1786 static int wm8753_remove(struct platform_device *pdev)
1787 {
1788         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1789         struct snd_soc_codec *codec = socdev->codec;
1790
1791         if (codec->control_data)
1792                 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1793         run_delayed_work(&codec->delayed_work);
1794         snd_soc_free_pcms(socdev);
1795         snd_soc_dapm_free(socdev);
1796 #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE)
1797         i2c_del_driver(&wm8753_i2c_driver);
1798 #endif
1799         kfree(codec->private_data);
1800         kfree(codec);
1801
1802         return 0;
1803 }
1804
1805 struct snd_soc_codec_device soc_codec_dev_wm8753 = {
1806         .probe =        wm8753_probe,
1807         .remove =       wm8753_remove,
1808         .suspend =      wm8753_suspend,
1809         .resume =       wm8753_resume,
1810 };
1811
1812 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8753);
1813
1814 MODULE_DESCRIPTION("ASoC WM8753 driver");
1815 MODULE_AUTHOR("Liam Girdwood");
1816 MODULE_LICENSE("GPL");