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],
 346                                                 codec, NULL));
 347                 if (err < 0)
 348                         return err;
 349         }
 350         return 0;
 351 }
 352
 353 /*
 354  * _DAPM_ Controls
 355  */
 356
 357 /* Left Mixer */
 358 static const struct snd_kcontrol_new wm8753_left_mixer_controls[] = {
 359 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_LOUTM2, 8, 1, 0),
 360 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_LOUTM2, 7, 1, 0),
 361 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_LOUTM1, 8, 1, 0),
 362 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_LOUTM1, 7, 1, 0),
 363 };
 364
 365 /* Right mixer */
 366 static const struct snd_kcontrol_new wm8753_right_mixer_controls[] = {
 367 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_ROUTM2, 8, 1, 0),
 368 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_ROUTM2, 7, 1, 0),
 369 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_ROUTM1, 8, 1, 0),
 370 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_ROUTM1, 7, 1, 0),
 371 };
 372
 373 /* Mono mixer */
 374 static const struct snd_kcontrol_new wm8753_mono_mixer_controls[] = {
 375 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_MOUTM1, 8, 1, 0),
 376 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_MOUTM2, 8, 1, 0),
 377 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_MOUTM2, 3, 1, 0),
 378 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_MOUTM2, 7, 1, 0),
 379 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_MOUTM1, 7, 1, 0),
 380 };
 381
 382 /* Mono 2 Mux */
 383 static const struct snd_kcontrol_new wm8753_mono2_controls =
 384 SOC_DAPM_ENUM("Route", wm8753_enum[17]);
 385
 386 /* Out 3 Mux */
 387 static const struct snd_kcontrol_new wm8753_out3_controls =
 388 SOC_DAPM_ENUM("Route", wm8753_enum[18]);
 389
 390 /* Out 4 Mux */
 391 static const struct snd_kcontrol_new wm8753_out4_controls =
 392 SOC_DAPM_ENUM("Route", wm8753_enum[19]);
 393
 394 /* ADC Mono Mix */
 395 static const struct snd_kcontrol_new wm8753_adc_mono_controls =
 396 SOC_DAPM_ENUM("Route", wm8753_enum[22]);
 397
 398 /* Record mixer */
 399 static const struct snd_kcontrol_new wm8753_record_mixer_controls[] = {
 400 SOC_DAPM_SINGLE("Voice Capture Switch", WM8753_RECMIX2, 3, 1, 0),
 401 SOC_DAPM_SINGLE("Left Capture Switch", WM8753_RECMIX1, 3, 1, 0),
 402 SOC_DAPM_SINGLE("Right Capture Switch", WM8753_RECMIX1, 7, 1, 0),
 403 };
 404
 405 /* Left ADC mux */
 406 static const struct snd_kcontrol_new wm8753_adc_left_controls =
 407 SOC_DAPM_ENUM("Route", wm8753_enum[21]);
 408
 409 /* Right ADC mux */
 410 static const struct snd_kcontrol_new wm8753_adc_right_controls =
 411 SOC_DAPM_ENUM("Route", wm8753_enum[20]);
 412
 413 /* MIC mux */
 414 static const struct snd_kcontrol_new wm8753_mic_mux_controls =
 415 SOC_DAPM_ENUM("Route", wm8753_enum[16]);
 416
 417 /* ALC mixer */
 418 static const struct snd_kcontrol_new wm8753_alc_mixer_controls[] = {
 419 SOC_DAPM_SINGLE("Line Capture Switch", WM8753_INCTL2, 3, 1, 0),
 420 SOC_DAPM_SINGLE("Mic2 Capture Switch", WM8753_INCTL2, 2, 1, 0),
 421 SOC_DAPM_SINGLE("Mic1 Capture Switch", WM8753_INCTL2, 1, 1, 0),
 422 SOC_DAPM_SINGLE("Rx Capture Switch", WM8753_INCTL2, 0, 1, 0),
 423 };
 424
 425 /* Left Line mux */
 426 static const struct snd_kcontrol_new wm8753_line_left_controls =
 427 SOC_DAPM_ENUM("Route", wm8753_enum[14]);
 428
 429 /* Right Line mux */
 430 static const struct snd_kcontrol_new wm8753_line_right_controls =
 431 SOC_DAPM_ENUM("Route", wm8753_enum[13]);
 432
 433 /* Mono Line mux */
 434 static const struct snd_kcontrol_new wm8753_line_mono_controls =
 435 SOC_DAPM_ENUM("Route", wm8753_enum[12]);
 436
 437 /* Line mux and mixer */
 438 static const struct snd_kcontrol_new wm8753_line_mux_mix_controls =
 439 SOC_DAPM_ENUM("Route", wm8753_enum[11]);
 440
 441 /* Rx mux and mixer */
 442 static const struct snd_kcontrol_new wm8753_rx_mux_mix_controls =
 443 SOC_DAPM_ENUM("Route", wm8753_enum[15]);
 444
 445 /* Mic Selector Mux */
 446 static const struct snd_kcontrol_new wm8753_mic_sel_mux_controls =
 447 SOC_DAPM_ENUM("Route", wm8753_enum[25]);
 448
 449 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
 450 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8753_PWR1, 5, 0),
 451 SND_SOC_DAPM_MIXER("Left Mixer", WM8753_PWR4, 0, 0,
 452         &wm8753_left_mixer_controls[0], ARRAY_SIZE(wm8753_left_mixer_controls)),
 453 SND_SOC_DAPM_PGA("Left Out 1", WM8753_PWR3, 8, 0, NULL, 0),
 454 SND_SOC_DAPM_PGA("Left Out 2", WM8753_PWR3, 6, 0, NULL, 0),
 455 SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback", WM8753_PWR1, 3, 0),
 456 SND_SOC_DAPM_OUTPUT("LOUT1"),
 457 SND_SOC_DAPM_OUTPUT("LOUT2"),
 458 SND_SOC_DAPM_MIXER("Right Mixer", WM8753_PWR4, 1, 0,
 459         &wm8753_right_mixer_controls[0], ARRAY_SIZE(wm8753_right_mixer_controls)),
 460 SND_SOC_DAPM_PGA("Right Out 1", WM8753_PWR3, 7, 0, NULL, 0),
 461 SND_SOC_DAPM_PGA("Right Out 2", WM8753_PWR3, 5, 0, NULL, 0),
 462 SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback", WM8753_PWR1, 2, 0),
 463 SND_SOC_DAPM_OUTPUT("ROUT1"),
 464 SND_SOC_DAPM_OUTPUT("ROUT2"),
 465 SND_SOC_DAPM_MIXER("Mono Mixer", WM8753_PWR4, 2, 0,
 466         &wm8753_mono_mixer_controls[0], ARRAY_SIZE(wm8753_mono_mixer_controls)),
 467 SND_SOC_DAPM_PGA("Mono Out 1", WM8753_PWR3, 2, 0, NULL, 0),
 468 SND_SOC_DAPM_PGA("Mono Out 2", WM8753_PWR3, 1, 0, NULL, 0),
 469 SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", WM8753_PWR1, 4, 0),
 470 SND_SOC_DAPM_OUTPUT("MONO1"),
 471 SND_SOC_DAPM_MUX("Mono 2 Mux", SND_SOC_NOPM, 0, 0, &wm8753_mono2_controls),
 472 SND_SOC_DAPM_OUTPUT("MONO2"),
 473 SND_SOC_DAPM_MIXER("Out3 Left + Right", -1, 0, 0, NULL, 0),
 474 SND_SOC_DAPM_MUX("Out3 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out3_controls),
 475 SND_SOC_DAPM_PGA("Out 3", WM8753_PWR3, 4, 0, NULL, 0),
 476 SND_SOC_DAPM_OUTPUT("OUT3"),
 477 SND_SOC_DAPM_MUX("Out4 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out4_controls),
 478 SND_SOC_DAPM_PGA("Out 4", WM8753_PWR3, 3, 0, NULL, 0),
 479 SND_SOC_DAPM_OUTPUT("OUT4"),
 480 SND_SOC_DAPM_MIXER("Playback Mixer", WM8753_PWR4, 3, 0,
 481         &wm8753_record_mixer_controls[0],
 482         ARRAY_SIZE(wm8753_record_mixer_controls)),
 483 SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8753_PWR2, 3, 0),
 484 SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8753_PWR2, 2, 0),
 485 SND_SOC_DAPM_MUX("Capture Left Mixer", SND_SOC_NOPM, 0, 0,
 486         &wm8753_adc_mono_controls),
 487 SND_SOC_DAPM_MUX("Capture Right Mixer", SND_SOC_NOPM, 0, 0,
 488         &wm8753_adc_mono_controls),
 489 SND_SOC_DAPM_MUX("Capture Left Mux", SND_SOC_NOPM, 0, 0,
 490         &wm8753_adc_left_controls),
 491 SND_SOC_DAPM_MUX("Capture Right Mux", SND_SOC_NOPM, 0, 0,
 492         &wm8753_adc_right_controls),
 493 SND_SOC_DAPM_MUX("Mic Sidetone Mux", SND_SOC_NOPM, 0, 0,
 494         &wm8753_mic_mux_controls),
 495 SND_SOC_DAPM_PGA("Left Capture Volume", WM8753_PWR2, 5, 0, NULL, 0),
 496 SND_SOC_DAPM_PGA("Right Capture Volume", WM8753_PWR2, 4, 0, NULL, 0),
 497 SND_SOC_DAPM_MIXER("ALC Mixer", WM8753_PWR2, 6, 0,
 498         &wm8753_alc_mixer_controls[0], ARRAY_SIZE(wm8753_alc_mixer_controls)),
 499 SND_SOC_DAPM_MUX("Line Left Mux", SND_SOC_NOPM, 0, 0,
 500         &wm8753_line_left_controls),
 501 SND_SOC_DAPM_MUX("Line Right Mux", SND_SOC_NOPM, 0, 0,
 502         &wm8753_line_right_controls),
 503 SND_SOC_DAPM_MUX("Line Mono Mux", SND_SOC_NOPM, 0, 0,
 504         &wm8753_line_mono_controls),
 505 SND_SOC_DAPM_MUX("Line Mixer", WM8753_PWR2, 0, 0,
 506         &wm8753_line_mux_mix_controls),
 507 SND_SOC_DAPM_MUX("Rx Mixer", WM8753_PWR2, 1, 0,
 508         &wm8753_rx_mux_mix_controls),
 509 SND_SOC_DAPM_PGA("Mic 1 Volume", WM8753_PWR2, 8, 0, NULL, 0),
 510 SND_SOC_DAPM_PGA("Mic 2 Volume", WM8753_PWR2, 7, 0, NULL, 0),
 511 SND_SOC_DAPM_MUX("Mic Selection Mux", SND_SOC_NOPM, 0, 0,
 512         &wm8753_mic_sel_mux_controls),
 513 SND_SOC_DAPM_INPUT("LINE1"),
 514 SND_SOC_DAPM_INPUT("LINE2"),
 515 SND_SOC_DAPM_INPUT("RXP"),
 516 SND_SOC_DAPM_INPUT("RXN"),
 517 SND_SOC_DAPM_INPUT("ACIN"),
 518 SND_SOC_DAPM_OUTPUT("ACOP"),
 519 SND_SOC_DAPM_INPUT("MIC1N"),
 520 SND_SOC_DAPM_INPUT("MIC1"),
 521 SND_SOC_DAPM_INPUT("MIC2N"),
 522 SND_SOC_DAPM_INPUT("MIC2"),
 523 SND_SOC_DAPM_VMID("VREF"),
 524 };
 525
 526 static const char *audio_map[][3] = {
 527         /* left mixer */
 528         {"Left Mixer", "Left Playback Switch", "Left DAC"},
 529         {"Left Mixer", "Voice Playback Switch", "Voice DAC"},
 530         {"Left Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 531         {"Left Mixer", "Bypass Playback Switch", "Line Left Mux"},
 532
 533         /* right mixer */
 534         {"Right Mixer", "Right Playback Switch", "Right DAC"},
 535         {"Right Mixer", "Voice Playback Switch", "Voice DAC"},
 536         {"Right Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 537         {"Right Mixer", "Bypass Playback Switch", "Line Right Mux"},
 538
 539         /* mono mixer */
 540         {"Mono Mixer", "Voice Playback Switch", "Voice DAC"},
 541         {"Mono Mixer", "Left Playback Switch", "Left DAC"},
 542         {"Mono Mixer", "Right Playback Switch", "Right DAC"},
 543         {"Mono Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
 544         {"Mono Mixer", "Bypass Playback Switch", "Line Mono Mux"},
 545
 546         /* left out */
 547         {"Left Out 1", NULL, "Left Mixer"},
 548         {"Left Out 2", NULL, "Left Mixer"},
 549         {"LOUT1", NULL, "Left Out 1"},
 550         {"LOUT2", NULL, "Left Out 2"},
 551
 552         /* right out */
 553         {"Right Out 1", NULL, "Right Mixer"},
 554         {"Right Out 2", NULL, "Right Mixer"},
 555         {"ROUT1", NULL, "Right Out 1"},
 556         {"ROUT2", NULL, "Right Out 2"},
 557
 558         /* mono 1 out */
 559         {"Mono Out 1", NULL, "Mono Mixer"},
 560         {"MONO1", NULL, "Mono Out 1"},
 561
 562         /* mono 2 out */
 563         {"Mono 2 Mux", "Left + Right", "Out3 Left + Right"},
 564         {"Mono 2 Mux", "Inverted Mono 1", "MONO1"},
 565         {"Mono 2 Mux", "Left", "Left Mixer"},
 566         {"Mono 2 Mux", "Right", "Right Mixer"},
 567         {"Mono Out 2", NULL, "Mono 2 Mux"},
 568         {"MONO2", NULL, "Mono Out 2"},
 569
 570         /* out 3 */
 571         {"Out3 Left + Right", NULL, "Left Mixer"},
 572         {"Out3 Left + Right", NULL, "Right Mixer"},
 573         {"Out3 Mux", "VREF", "VREF"},
 574         {"Out3 Mux", "Left + Right", "Out3 Left + Right"},
 575         {"Out3 Mux", "ROUT2", "ROUT2"},
 576         {"Out 3", NULL, "Out3 Mux"},
 577         {"OUT3", NULL, "Out 3"},
 578
 579         /* out 4 */
 580         {"Out4 Mux", "VREF", "VREF"},
 581         {"Out4 Mux", "Capture ST", "Capture ST Mixer"},
 582         {"Out4 Mux", "LOUT2", "LOUT2"},
 583         {"Out 4", NULL, "Out4 Mux"},
 584         {"OUT4", NULL, "Out 4"},
 585
 586         /* record mixer  */
 587         {"Playback Mixer", "Left Capture Switch", "Left Mixer"},
 588         {"Playback Mixer", "Voice Capture Switch", "Mono Mixer"},
 589         {"Playback Mixer", "Right Capture Switch", "Right Mixer"},
 590
 591         /* Mic/SideTone Mux */
 592         {"Mic Sidetone Mux", "Left PGA", "Left Capture Volume"},
 593         {"Mic Sidetone Mux", "Right PGA", "Right Capture Volume"},
 594         {"Mic Sidetone Mux", "Mic 1", "Mic 1 Volume"},
 595         {"Mic Sidetone Mux", "Mic 2", "Mic 2 Volume"},
 596
 597         /* Capture Left Mux */
 598         {"Capture Left Mux", "PGA", "Left Capture Volume"},
 599         {"Capture Left Mux", "Line or RXP-RXN", "Line Left Mux"},
 600         {"Capture Left Mux", "Line", "LINE1"},
 601
 602         /* Capture Right Mux */
 603         {"Capture Right Mux", "PGA", "Right Capture Volume"},
 604         {"Capture Right Mux", "Line or RXP-RXN", "Line Right Mux"},
 605         {"Capture Right Mux", "Sidetone", "Capture ST Mixer"},
 606
 607         /* Mono Capture mixer-mux */
 608         {"Capture Right Mixer", "Stereo", "Capture Right Mux"},
 609         {"Capture Left Mixer", "Analogue Mix Left", "Capture Left Mux"},
 610         {"Capture Left Mixer", "Analogue Mix Left", "Capture Right Mux"},
 611         {"Capture Right Mixer", "Analogue Mix Right", "Capture Left Mux"},
 612         {"Capture Right Mixer", "Analogue Mix Right", "Capture Right Mux"},
 613         {"Capture Left Mixer", "Digital Mono Mix", "Capture Left Mux"},
 614         {"Capture Left Mixer", "Digital Mono Mix", "Capture Right Mux"},
 615         {"Capture Right Mixer", "Digital Mono Mix", "Capture Left Mux"},
 616         {"Capture Right Mixer", "Digital Mono Mix", "Capture Right Mux"},
 617
 618         /* ADC */
 619         {"Left ADC", NULL, "Capture Left Mixer"},
 620         {"Right ADC", NULL, "Capture Right Mixer"},
 621
 622         /* Left Capture Volume */
 623         {"Left Capture Volume", NULL, "ACIN"},
 624
 625         /* Right Capture Volume */
 626         {"Right Capture Volume", NULL, "Mic 2 Volume"},
 627
 628         /* ALC Mixer */
 629         {"ALC Mixer", "Line Capture Switch", "Line Mixer"},
 630         {"ALC Mixer", "Mic2 Capture Switch", "Mic 2 Volume"},
 631         {"ALC Mixer", "Mic1 Capture Switch", "Mic 1 Volume"},
 632         {"ALC Mixer", "Rx Capture Switch", "Rx Mixer"},
 633
 634         /* Line Left Mux */
 635         {"Line Left Mux", "Line 1", "LINE1"},
 636         {"Line Left Mux", "Rx Mix", "Rx Mixer"},
 637
 638         /* Line Right Mux */
 639         {"Line Right Mux", "Line 2", "LINE2"},
 640         {"Line Right Mux", "Rx Mix", "Rx Mixer"},
 641
 642         /* Line Mono Mux */
 643         {"Line Mono Mux", "Line Mix", "Line Mixer"},
 644         {"Line Mono Mux", "Rx Mix", "Rx Mixer"},
 645
 646         /* Line Mixer/Mux */
 647         {"Line Mixer", "Line 1 + 2", "LINE1"},
 648         {"Line Mixer", "Line 1 - 2", "LINE1"},
 649         {"Line Mixer", "Line 1 + 2", "LINE2"},
 650         {"Line Mixer", "Line 1 - 2", "LINE2"},
 651         {"Line Mixer", "Line 1", "LINE1"},
 652         {"Line Mixer", "Line 2", "LINE2"},
 653
 654         /* Rx Mixer/Mux */
 655         {"Rx Mixer", "RXP - RXN", "RXP"},
 656         {"Rx Mixer", "RXP + RXN", "RXP"},
 657         {"Rx Mixer", "RXP - RXN", "RXN"},
 658         {"Rx Mixer", "RXP + RXN", "RXN"},
 659         {"Rx Mixer", "RXP", "RXP"},
 660         {"Rx Mixer", "RXN", "RXN"},
 661
 662         /* Mic 1 Volume */
 663         {"Mic 1 Volume", NULL, "MIC1N"},
 664         {"Mic 1 Volume", NULL, "Mic Selection Mux"},
 665
 666         /* Mic 2 Volume */
 667         {"Mic 2 Volume", NULL, "MIC2N"},
 668         {"Mic 2 Volume", NULL, "MIC2"},
 669
 670         /* Mic Selector Mux */
 671         {"Mic Selection Mux", "Mic 1", "MIC1"},
 672         {"Mic Selection Mux", "Mic 2", "MIC2N"},
 673         {"Mic Selection Mux", "Mic 3", "MIC2"},
 674
 675         /* ACOP */
 676         {"ACOP", NULL, "ALC Mixer"},
 677
 678         /* terminator */
 679         {NULL, NULL, NULL},
 680 };
 681
 682 static int wm8753_add_widgets(struct snd_soc_codec *codec)
 683 {
 684         int i;
 685
 686         for (i = 0; i < ARRAY_SIZE(wm8753_dapm_widgets); i++)
 687                 snd_soc_dapm_new_control(codec, &wm8753_dapm_widgets[i]);
 688
 689         /* set up the WM8753 audio map */
 690         for (i = 0; audio_map[i][0] != NULL; i++) {
 691                 snd_soc_dapm_connect_input(codec, audio_map[i][0],
 692                         audio_map[i][1], audio_map[i][2]);
 693         }
 694
 695         snd_soc_dapm_new_widgets(codec);
 696         return 0;
 697 }
 698
 699 /* PLL divisors */
 700 struct _pll_div {
 701         u32 div2:1;
 702         u32 n:4;
 703         u32 k:24;
 704 };
 705
 706 /* The size in bits of the pll divide multiplied by 10
 707  * to allow rounding later */
 708 #define FIXED_PLL_SIZE ((1 << 22) * 10)
 709
 710 static void pll_factors(struct _pll_div *pll_div, unsigned int target,
 711         unsigned int source)
 712 {
 713         u64 Kpart;
 714         unsigned int K, Ndiv, Nmod;
 715
 716         Ndiv = target / source;
 717         if (Ndiv < 6) {
 718                 source >>= 1;
 719                 pll_div->div2 = 1;
 720                 Ndiv = target / source;
 721         } else
 722                 pll_div->div2 = 0;
 723
 724         if ((Ndiv < 6) || (Ndiv > 12))
 725                 printk(KERN_WARNING
 726                         "wm8753: unsupported N = %d\n", Ndiv);
 727
 728         pll_div->n = Ndiv;
 729         Nmod = target % source;
 730         Kpart = FIXED_PLL_SIZE * (long long)Nmod;
 731
 732         do_div(Kpart, source);
 733
 734         K = Kpart & 0xFFFFFFFF;
 735
 736         /* Check if we need to round */
 737         if ((K % 10) >= 5)
 738                 K += 5;
 739
 740         /* Move down to proper range now rounding is done */
 741         K /= 10;
 742
 743         pll_div->k = K;
 744 }
 745
 746 static int wm8753_set_dai_pll(struct snd_soc_codec_dai *codec_dai,
 747                 int pll_id, unsigned int freq_in, unsigned int freq_out)
 748 {
 749         u16 reg, enable;
 750         int offset;
 751         struct snd_soc_codec *codec = codec_dai->codec;
 752
 753         if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2)
 754                 return -ENODEV;
 755
 756         if (pll_id == WM8753_PLL1) {
 757                 offset = 0;
 758                 enable = 0x10;
 759                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xffef;
 760         } else {
 761                 offset = 4;
 762                 enable = 0x8;
 763                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfff7;
 764         }
 765
 766         if (!freq_in || !freq_out) {
 767                 /* disable PLL  */
 768                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0026);
 769                 wm8753_write(codec, WM8753_CLOCK, reg);
 770                 return 0;
 771         } else {
 772                 u16 value = 0;
 773                 struct _pll_div pll_div;
 774
 775                 pll_factors(&pll_div, freq_out * 8, freq_in);
 776
 777                 /* set up N and K PLL divisor ratios */
 778                 /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */
 779                 value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18);
 780                 wm8753_write(codec, WM8753_PLL1CTL2 + offset, value);
 781
 782                 /* bits 8:0 = PLL_K[17:9] */
 783                 value = (pll_div.k & 0x03fe00) >> 9;
 784                 wm8753_write(codec, WM8753_PLL1CTL3 + offset, value);
 785
 786                 /* bits 8:0 = PLL_K[8:0] */
 787                 value = pll_div.k & 0x0001ff;
 788                 wm8753_write(codec, WM8753_PLL1CTL4 + offset, value);
 789
 790                 /* set PLL as input and enable */
 791                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 |
 792                         (pll_div.div2 << 3));
 793                 wm8753_write(codec, WM8753_CLOCK, reg | enable);
 794         }
 795         return 0;
 796 }
 797
 798 struct _coeff_div {
 799         u32 mclk;
 800         u32 rate;
 801         u8 sr:5;
 802         u8 usb:1;
 803 };
 804
 805 /* codec hifi mclk (after PLL) clock divider coefficients */
 806 static const struct _coeff_div coeff_div[] = {
 807         /* 8k */
 808         {12288000, 8000, 0x6, 0x0},
 809         {11289600, 8000, 0x16, 0x0},
 810         {18432000, 8000, 0x7, 0x0},
 811         {16934400, 8000, 0x17, 0x0},
 812         {12000000, 8000, 0x6, 0x1},
 813
 814         /* 11.025k */
 815         {11289600, 11025, 0x18, 0x0},
 816         {16934400, 11025, 0x19, 0x0},
 817         {12000000, 11025, 0x19, 0x1},
 818
 819         /* 16k */
 820         {12288000, 16000, 0xa, 0x0},
 821         {18432000, 16000, 0xb, 0x0},
 822         {12000000, 16000, 0xa, 0x1},
 823
 824         /* 22.05k */
 825         {11289600, 22050, 0x1a, 0x0},
 826         {16934400, 22050, 0x1b, 0x0},
 827         {12000000, 22050, 0x1b, 0x1},
 828
 829         /* 32k */
 830         {12288000, 32000, 0xc, 0x0},
 831         {18432000, 32000, 0xd, 0x0},
 832         {12000000, 32000, 0xa, 0x1},
 833
 834         /* 44.1k */
 835         {11289600, 44100, 0x10, 0x0},
 836         {16934400, 44100, 0x11, 0x0},
 837         {12000000, 44100, 0x11, 0x1},
 838
 839         /* 48k */
 840         {12288000, 48000, 0x0, 0x0},
 841         {18432000, 48000, 0x1, 0x0},
 842         {12000000, 48000, 0x0, 0x1},
 843
 844         /* 88.2k */
 845         {11289600, 88200, 0x1e, 0x0},
 846         {16934400, 88200, 0x1f, 0x0},
 847         {12000000, 88200, 0x1f, 0x1},
 848
 849         /* 96k */
 850         {12288000, 96000, 0xe, 0x0},
 851         {18432000, 96000, 0xf, 0x0},
 852         {12000000, 96000, 0xe, 0x1},
 853 };
 854
 855 static int get_coeff(int mclk, int rate)
 856 {
 857         int i;
 858
 859         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
 860                 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
 861                         return i;
 862         }
 863         return -EINVAL;
 864 }
 865
 866 /*
 867  * Clock after PLL and dividers
 868  */
 869 static int wm8753_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai,
 870                 int clk_id, unsigned int freq, int dir)
 871 {
 872         struct snd_soc_codec *codec = codec_dai->codec;
 873         struct wm8753_priv *wm8753 = codec->private_data;
 874
 875         switch (freq) {
 876         case 11289600:
 877         case 12000000:
 878         case 12288000:
 879         case 16934400:
 880         case 18432000:
 881                 if (clk_id == WM8753_MCLK) {
 882                         wm8753->sysclk = freq;
 883                         return 0;
 884                 } else if (clk_id == WM8753_PCMCLK) {
 885                         wm8753->pcmclk = freq;
 886                         return 0;
 887                 }
 888                 break;
 889         }
 890         return -EINVAL;
 891 }
 892
 893 /*
 894  * Set's ADC and Voice DAC format.
 895  */
 896 static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 897                 unsigned int fmt)
 898 {
 899         struct snd_soc_codec *codec = codec_dai->codec;
 900         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01ec;
 901
 902         /* interface format */
 903         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 904         case SND_SOC_DAIFMT_I2S:
 905                 voice |= 0x0002;
 906                 break;
 907         case SND_SOC_DAIFMT_RIGHT_J:
 908                 break;
 909         case SND_SOC_DAIFMT_LEFT_J:
 910                 voice |= 0x0001;
 911                 break;
 912         case SND_SOC_DAIFMT_DSP_A:
 913                 voice |= 0x0003;
 914                 break;
 915         case SND_SOC_DAIFMT_DSP_B:
 916                 voice |= 0x0013;
 917                 break;
 918         default:
 919                 return -EINVAL;
 920         }
 921
 922         wm8753_write(codec, WM8753_PCM, voice);
 923         return 0;
 924 }
 925
 926 /*
 927  * Set PCM DAI bit size and sample rate.
 928  */
 929 static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream,
 930         struct snd_pcm_hw_params *params)
 931 {
 932         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 933         struct snd_soc_device *socdev = rtd->socdev;
 934         struct snd_soc_codec *codec = socdev->codec;
 935         struct wm8753_priv *wm8753 = codec->private_data;
 936         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01f3;
 937         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x017f;
 938
 939         /* bit size */
 940         switch (params_format(params)) {
 941         case SNDRV_PCM_FORMAT_S16_LE:
 942                 break;
 943         case SNDRV_PCM_FORMAT_S20_3LE:
 944                 voice |= 0x0004;
 945                 break;
 946         case SNDRV_PCM_FORMAT_S24_LE:
 947                 voice |= 0x0008;
 948                 break;
 949         case SNDRV_PCM_FORMAT_S32_LE:
 950                 voice |= 0x000c;
 951                 break;
 952         }
 953
 954         /* sample rate */
 955         if (params_rate(params) * 384 == wm8753->pcmclk)
 956                 srate |= 0x80;
 957         wm8753_write(codec, WM8753_SRATE1, srate);
 958
 959         wm8753_write(codec, WM8753_PCM, voice);
 960         return 0;
 961 }
 962
 963 /*
 964  * Set's PCM dai fmt and BCLK.
 965  */
 966 static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 967                 unsigned int fmt)
 968 {
 969         struct snd_soc_codec *codec = codec_dai->codec;
 970         u16 voice, ioctl;
 971
 972         voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x011f;
 973         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x015d;
 974
 975         /* set master/slave audio interface */
 976         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 977         case SND_SOC_DAIFMT_CBS_CFS:
 978                 break;
 979         case SND_SOC_DAIFMT_CBM_CFM:
 980                 ioctl |= 0x2;
 981         case SND_SOC_DAIFMT_CBM_CFS:
 982                 voice |= 0x0040;
 983                 break;
 984         default:
 985                 return -EINVAL;
 986         }
 987
 988         /* clock inversion */
 989         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 990         case SND_SOC_DAIFMT_DSP_A:
 991         case SND_SOC_DAIFMT_DSP_B:
 992                 /* frame inversion not valid for DSP modes */
 993                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 994                 case SND_SOC_DAIFMT_NB_NF:
 995                         break;
 996                 case SND_SOC_DAIFMT_IB_NF:
 997                         voice |= 0x0080;
 998                         break;
 999                 default:
1000                         return -EINVAL;
1001                 }
1002                 break;
1003         case SND_SOC_DAIFMT_I2S:
1004         case SND_SOC_DAIFMT_RIGHT_J:
1005         case SND_SOC_DAIFMT_LEFT_J:
1006                 voice &= ~0x0010;
1007                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1008                 case SND_SOC_DAIFMT_NB_NF:
1009                         break;
1010                 case SND_SOC_DAIFMT_IB_IF:
1011                         voice |= 0x0090;
1012                         break;
1013                 case SND_SOC_DAIFMT_IB_NF:
1014                         voice |= 0x0080;
1015                         break;
1016                 case SND_SOC_DAIFMT_NB_IF:
1017                         voice |= 0x0010;
1018                         break;
1019                 default:
1020                         return -EINVAL;
1021                 }
1022                 break;
1023         default:
1024                 return -EINVAL;
1025         }
1026
1027         wm8753_write(codec, WM8753_PCM, voice);
1028         wm8753_write(codec, WM8753_IOCTL, ioctl);
1029         return 0;
1030 }
1031
1032 static int wm8753_set_dai_clkdiv(struct snd_soc_codec_dai *codec_dai,
1033                 int div_id, int div)
1034 {
1035         struct snd_soc_codec *codec = codec_dai->codec;
1036         u16 reg;
1037
1038         switch (div_id) {
1039         case WM8753_PCMDIV:
1040                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0x003f;
1041                 wm8753_write(codec, WM8753_CLOCK, reg | div);
1042                 break;
1043         case WM8753_BCLKDIV:
1044                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x01c7;
1045                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1046                 break;
1047         case WM8753_VXCLKDIV:
1048                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x003f;
1049                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1050                 break;
1051         default:
1052                 return -EINVAL;
1053         }
1054         return 0;
1055 }
1056
1057 /*
1058  * Set's HiFi DAC format.
1059  */
1060 static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1061                 unsigned int fmt)
1062 {
1063         struct snd_soc_codec *codec = codec_dai->codec;
1064         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01e0;
1065
1066         /* interface format */
1067         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1068         case SND_SOC_DAIFMT_I2S:
1069                 hifi |= 0x0002;
1070                 break;
1071         case SND_SOC_DAIFMT_RIGHT_J:
1072                 break;
1073         case SND_SOC_DAIFMT_LEFT_J:
1074                 hifi |= 0x0001;
1075                 break;
1076         case SND_SOC_DAIFMT_DSP_A:
1077                 hifi |= 0x0003;
1078                 break;
1079         case SND_SOC_DAIFMT_DSP_B:
1080                 hifi |= 0x0013;
1081                 break;
1082         default:
1083                 return -EINVAL;
1084         }
1085
1086         wm8753_write(codec, WM8753_HIFI, hifi);
1087         return 0;
1088 }
1089
1090 /*
1091  * Set's I2S DAI format.
1092  */
1093 static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1094                 unsigned int fmt)
1095 {
1096         struct snd_soc_codec *codec = codec_dai->codec;
1097         u16 ioctl, hifi;
1098
1099         hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x011f;
1100         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x00ae;
1101
1102         /* set master/slave audio interface */
1103         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1104         case SND_SOC_DAIFMT_CBS_CFS:
1105                 break;
1106         case SND_SOC_DAIFMT_CBM_CFM:
1107                 ioctl |= 0x1;
1108         case SND_SOC_DAIFMT_CBM_CFS:
1109                 hifi |= 0x0040;
1110                 break;
1111         default:
1112                 return -EINVAL;
1113         }
1114
1115         /* clock inversion */
1116         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1117         case SND_SOC_DAIFMT_DSP_A:
1118         case SND_SOC_DAIFMT_DSP_B:
1119                 /* frame inversion not valid for DSP modes */
1120                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1121                 case SND_SOC_DAIFMT_NB_NF:
1122                         break;
1123                 case SND_SOC_DAIFMT_IB_NF:
1124                         hifi |= 0x0080;
1125                         break;
1126                 default:
1127                         return -EINVAL;
1128                 }
1129                 break;
1130         case SND_SOC_DAIFMT_I2S:
1131         case SND_SOC_DAIFMT_RIGHT_J:
1132         case SND_SOC_DAIFMT_LEFT_J:
1133                 hifi &= ~0x0010;
1134                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1135                 case SND_SOC_DAIFMT_NB_NF:
1136                         break;
1137                 case SND_SOC_DAIFMT_IB_IF:
1138                         hifi |= 0x0090;
1139                         break;
1140                 case SND_SOC_DAIFMT_IB_NF:
1141                         hifi |= 0x0080;
1142                         break;
1143                 case SND_SOC_DAIFMT_NB_IF:
1144                         hifi |= 0x0010;
1145                         break;
1146                 default:
1147                         return -EINVAL;
1148                 }
1149                 break;
1150         default:
1151                 return -EINVAL;
1152         }
1153
1154         wm8753_write(codec, WM8753_HIFI, hifi);
1155         wm8753_write(codec, WM8753_IOCTL, ioctl);
1156         return 0;
1157 }
1158
1159 /*
1160  * Set PCM DAI bit size and sample rate.
1161  */
1162 static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream,
1163         struct snd_pcm_hw_params *params)
1164 {
1165         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1166         struct snd_soc_device *socdev = rtd->socdev;
1167         struct snd_soc_codec *codec = socdev->codec;
1168         struct wm8753_priv *wm8753 = codec->private_data;
1169         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x01c0;
1170         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01f3;
1171         int coeff;
1172
1173         /* is digital filter coefficient valid ? */
1174         coeff = get_coeff(wm8753->sysclk, params_rate(params));
1175         if (coeff < 0) {
1176                 printk(KERN_ERR "wm8753 invalid MCLK or rate\n");
1177                 return coeff;
1178         }
1179         wm8753_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) |
1180                 coeff_div[coeff].usb);
1181
1182         /* bit size */
1183         switch (params_format(params)) {
1184         case SNDRV_PCM_FORMAT_S16_LE:
1185                 break;
1186         case SNDRV_PCM_FORMAT_S20_3LE:
1187                 hifi |= 0x0004;
1188                 break;
1189         case SNDRV_PCM_FORMAT_S24_LE:
1190                 hifi |= 0x0008;
1191                 break;
1192         case SNDRV_PCM_FORMAT_S32_LE:
1193                 hifi |= 0x000c;
1194                 break;
1195         }
1196
1197         wm8753_write(codec, WM8753_HIFI, hifi);
1198         return 0;
1199 }
1200
1201 static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1202                 unsigned int fmt)
1203 {
1204         struct snd_soc_codec *codec = codec_dai->codec;
1205         u16 clock;
1206
1207         /* set clk source as pcmclk */
1208         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1209         wm8753_write(codec, WM8753_CLOCK, clock);
1210
1211         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1212                 return -EINVAL;
1213         return wm8753_pcm_set_dai_fmt(codec_dai, fmt);
1214 }
1215
1216 static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1217                 unsigned int fmt)
1218 {
1219         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1220                 return -EINVAL;
1221         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1222 }
1223
1224 static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1225                 unsigned int fmt)
1226 {
1227         struct snd_soc_codec *codec = codec_dai->codec;
1228         u16 clock;
1229
1230         /* set clk source as pcmclk */
1231         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1232         wm8753_write(codec, WM8753_CLOCK, clock);
1233
1234         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1235                 return -EINVAL;
1236         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1237 }
1238
1239 static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1240                 unsigned int fmt)
1241 {
1242         struct snd_soc_codec *codec = codec_dai->codec;
1243         u16 clock;
1244
1245         /* set clk source as mclk */
1246         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1247         wm8753_write(codec, WM8753_CLOCK, clock | 0x4);
1248
1249         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1250                 return -EINVAL;
1251         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1252                 return -EINVAL;
1253         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1254 }
1255
1256 static int wm8753_mute(struct snd_soc_codec_dai *dai, int mute)
1257 {
1258         struct snd_soc_codec *codec = dai->codec;
1259         u16 mute_reg = wm8753_read_reg_cache(codec, WM8753_DAC) & 0xfff7;
1260
1261         /* the digital mute covers the HiFi and Voice DAC's on the WM8753.
1262          * make sure we check if they are not both active when we mute */
1263         if (mute && dai->id == 1) {
1264                 if (!wm8753_dai[WM8753_DAI_VOICE].playback.active ||
1265                         !wm8753_dai[WM8753_DAI_HIFI].playback.active)
1266                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1267         } else {
1268                 if (mute)
1269                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1270                 else
1271                         wm8753_write(codec, WM8753_DAC, mute_reg);
1272         }
1273
1274         return 0;
1275 }
1276
1277 static int wm8753_dapm_event(struct snd_soc_codec *codec, int event)
1278 {
1279         u16 pwr_reg = wm8753_read_reg_cache(codec, WM8753_PWR1) & 0xfe3e;
1280
1281         switch (event) {
1282         case SNDRV_CTL_POWER_D0: /* full On */
1283                 /* set vmid to 50k and unmute dac */
1284                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
1285                 break;
1286         case SNDRV_CTL_POWER_D1: /* partial On */
1287         case SNDRV_CTL_POWER_D2: /* partial On */
1288                 /* set vmid to 5k for quick power up */
1289                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
1290                 break;
1291         case SNDRV_CTL_POWER_D3hot: /* Off, with power */
1292                 /* mute dac and set vmid to 500k, enable VREF */
1293                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
1294                 break;
1295         case SNDRV_CTL_POWER_D3cold: /* Off, without power */
1296                 wm8753_write(codec, WM8753_PWR1, 0x0001);
1297                 break;
1298         }
1299         codec->dapm_state = event;
1300         return 0;
1301 }
1302
1303 #define WM8753_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
1304                 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
1305                 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
1306                 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
1307
1308 #define WM8753_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1309         SNDRV_PCM_FMTBIT_S24_LE)
1310
1311 /*
1312  * The WM8753 supports upto 4 different and mutually exclusive DAI
1313  * configurations. This gives 2 PCM's available for use, hifi and voice.
1314  * NOTE: The Voice PCM cannot play or capture audio to the CPU as it's DAI
1315  * is connected between the wm8753 and a BT codec or GSM modem.
1316  *
1317  * 1. Voice over PCM DAI - HIFI DAC over HIFI DAI
1318  * 2. Voice over HIFI DAI - HIFI disabled
1319  * 3. Voice disabled - HIFI over HIFI
1320  * 4. Voice disabled - HIFI over HIFI, uses voice DAI LRC for capture
1321  */
1322 static const struct snd_soc_codec_dai wm8753_all_dai[] = {
1323 /* DAI HiFi mode 1 */
1324 {       .name = "WM8753 HiFi",
1325         .id = 1,
1326         .playback = {
1327                 .stream_name = "HiFi Playback",
1328                 .channels_min = 1,
1329                 .channels_max = 2,
1330                 .rates = WM8753_RATES,
1331                 .formats = WM8753_FORMATS,},
1332         .capture = { /* dummy for fast DAI switching */
1333                 .stream_name = "Capture",
1334                 .channels_min = 1,
1335                 .channels_max = 2,
1336                 .rates = WM8753_RATES,
1337                 .formats = WM8753_FORMATS,},
1338         .ops = {
1339                 .hw_params = wm8753_i2s_hw_params,},
1340         .dai_ops = {
1341                 .digital_mute = wm8753_mute,
1342                 .set_fmt = wm8753_mode1h_set_dai_fmt,
1343                 .set_clkdiv = wm8753_set_dai_clkdiv,
1344                 .set_pll = wm8753_set_dai_pll,
1345                 .set_sysclk = wm8753_set_dai_sysclk,
1346         },
1347 },
1348 /* DAI Voice mode 1 */
1349 {       .name = "WM8753 Voice",
1350         .id = 1,
1351         .playback = {
1352                 .stream_name = "Voice Playback",
1353                 .channels_min = 1,
1354                 .channels_max = 1,
1355                 .rates = WM8753_RATES,
1356                 .formats = WM8753_FORMATS,},
1357         .capture = {
1358                 .stream_name = "Capture",
1359                 .channels_min = 1,
1360                 .channels_max = 2,
1361                 .rates = WM8753_RATES,
1362                 .formats = WM8753_FORMATS,},
1363         .ops = {
1364                 .hw_params = wm8753_pcm_hw_params,},
1365         .dai_ops = {
1366                 .digital_mute = wm8753_mute,
1367                 .set_fmt = wm8753_mode1v_set_dai_fmt,
1368                 .set_clkdiv = wm8753_set_dai_clkdiv,
1369                 .set_pll = wm8753_set_dai_pll,
1370                 .set_sysclk = wm8753_set_dai_sysclk,
1371         },
1372 },
1373 /* DAI HiFi mode 2 - dummy */
1374 {       .name = "WM8753 HiFi",
1375         .id = 2,
1376 },
1377 /* DAI Voice mode 2 */
1378 {       .name = "WM8753 Voice",
1379         .id = 2,
1380         .playback = {
1381                 .stream_name = "Voice Playback",
1382                 .channels_min = 1,
1383                 .channels_max = 1,
1384                 .rates = WM8753_RATES,
1385                 .formats = WM8753_FORMATS,},
1386         .capture = {
1387                 .stream_name = "Capture",
1388                 .channels_min = 1,
1389                 .channels_max = 2,
1390                 .rates = WM8753_RATES,
1391                 .formats = WM8753_FORMATS,},
1392         .ops = {
1393                 .hw_params = wm8753_pcm_hw_params,},
1394         .dai_ops = {
1395                 .digital_mute = wm8753_mute,
1396                 .set_fmt = wm8753_mode2_set_dai_fmt,
1397                 .set_clkdiv = wm8753_set_dai_clkdiv,
1398                 .set_pll = wm8753_set_dai_pll,
1399                 .set_sysclk = wm8753_set_dai_sysclk,
1400         },
1401 },
1402 /* DAI HiFi mode 3 */
1403 {       .name = "WM8753 HiFi",
1404         .id = 3,
1405         .playback = {
1406                 .stream_name = "HiFi Playback",
1407                 .channels_min = 1,
1408                 .channels_max = 2,
1409                 .rates = WM8753_RATES,
1410                 .formats = WM8753_FORMATS,},
1411         .capture = {
1412                 .stream_name = "Capture",
1413                 .channels_min = 1,
1414                 .channels_max = 2,
1415                 .rates = WM8753_RATES,
1416                 .formats = WM8753_FORMATS,},
1417         .ops = {
1418                 .hw_params = wm8753_i2s_hw_params,},
1419         .dai_ops = {
1420                 .digital_mute = wm8753_mute,
1421                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1422                 .set_clkdiv = wm8753_set_dai_clkdiv,
1423                 .set_pll = wm8753_set_dai_pll,
1424                 .set_sysclk = wm8753_set_dai_sysclk,
1425         },
1426 },
1427 /* DAI Voice mode 3 - dummy */
1428 {       .name = "WM8753 Voice",
1429         .id = 3,
1430 },
1431 /* DAI HiFi mode 4 */
1432 {       .name = "WM8753 HiFi",
1433         .id = 4,
1434         .playback = {
1435                 .stream_name = "HiFi Playback",
1436                 .channels_min = 1,
1437                 .channels_max = 2,
1438                 .rates = WM8753_RATES,
1439                 .formats = WM8753_FORMATS,},
1440         .capture = {
1441                 .stream_name = "Capture",
1442                 .channels_min = 1,
1443                 .channels_max = 2,
1444                 .rates = WM8753_RATES,
1445                 .formats = WM8753_FORMATS,},
1446         .ops = {
1447                 .hw_params = wm8753_i2s_hw_params,},
1448         .dai_ops = {
1449                 .digital_mute = wm8753_mute,
1450                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1451                 .set_clkdiv = wm8753_set_dai_clkdiv,
1452                 .set_pll = wm8753_set_dai_pll,
1453                 .set_sysclk = wm8753_set_dai_sysclk,
1454         },
1455 },
1456 /* DAI Voice mode 4 - dummy */
1457 {       .name = "WM8753 Voice",
1458         .id = 4,
1459 },
1460 };
1461
1462 struct snd_soc_codec_dai wm8753_dai[2];
1463 EXPORT_SYMBOL_GPL(wm8753_dai);
1464
1465 static void wm8753_set_dai_mode(struct snd_soc_codec *codec, unsigned int mode)
1466 {
1467         if (mode < 4) {
1468                 int playback_active, capture_active, codec_active, pop_wait;
1469                 void *private_data;
1470
1471                 playback_active = wm8753_dai[0].playback.active;
1472                 capture_active = wm8753_dai[0].capture.active;
1473                 codec_active = wm8753_dai[0].active;
1474                 private_data = wm8753_dai[0].private_data;
1475                 pop_wait = wm8753_dai[0].pop_wait;
1476                 wm8753_dai[0] = wm8753_all_dai[mode << 1];
1477                 wm8753_dai[0].playback.active = playback_active;
1478                 wm8753_dai[0].capture.active = capture_active;
1479                 wm8753_dai[0].active = codec_active;
1480                 wm8753_dai[0].private_data = private_data;
1481                 wm8753_dai[0].pop_wait = pop_wait;
1482
1483                 playback_active = wm8753_dai[1].playback.active;
1484                 capture_active = wm8753_dai[1].capture.active;
1485                 codec_active = wm8753_dai[1].active;
1486                 private_data = wm8753_dai[1].private_data;
1487                 pop_wait = wm8753_dai[1].pop_wait;
1488                 wm8753_dai[1] = wm8753_all_dai[(mode << 1) + 1];
1489                 wm8753_dai[1].playback.active = playback_active;
1490                 wm8753_dai[1].capture.active = capture_active;
1491                 wm8753_dai[1].active = codec_active;
1492                 wm8753_dai[1].private_data = private_data;
1493                 wm8753_dai[1].pop_wait = pop_wait;
1494         }
1495         wm8753_dai[0].codec = codec;
1496         wm8753_dai[1].codec = codec;
1497 }
1498
1499 static void wm8753_work(struct work_struct *work)
1500 {
1501         struct snd_soc_codec *codec =
1502                 container_of(work, struct snd_soc_codec, delayed_work.work);
1503         wm8753_dapm_event(codec, codec->dapm_state);
1504 }
1505
1506 static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
1507 {
1508         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1509         struct snd_soc_codec *codec = socdev->codec;
1510
1511         /* we only need to suspend if we are a valid card */
1512         if (!codec->card)
1513                 return 0;
1514
1515         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1516         return 0;
1517 }
1518
1519 static int wm8753_resume(struct platform_device *pdev)
1520 {
1521         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1522         struct snd_soc_codec *codec = socdev->codec;
1523         int i;
1524         u8 data[2];
1525         u16 *cache = codec->reg_cache;
1526
1527         /* we only need to resume if we are a valid card */
1528         if (!codec->card)
1529                 return 0;
1530
1531         /* Sync reg_cache with the hardware */
1532         for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
1533                 if (i + 1 == WM8753_RESET)
1534                         continue;
1535                 data[0] = ((i + 1) << 1) | ((cache[i] >> 8) & 0x0001);
1536                 data[1] = cache[i] & 0x00ff;
1537                 codec->hw_write(codec->control_data, data, 2);
1538         }
1539
1540         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3hot);
1541
1542         /* charge wm8753 caps */
1543         if (codec->suspend_dapm_state == SNDRV_CTL_POWER_D0) {
1544                 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1545                 codec->dapm_state = SNDRV_CTL_POWER_D0;
1546                 schedule_delayed_work(&codec->delayed_work,
1547                         msecs_to_jiffies(caps_charge));
1548         }
1549
1550         return 0;
1551 }
1552
1553 /*
1554  * initialise the WM8753 driver
1555  * register the mixer and dsp interfaces with the kernel
1556  */
1557 static int wm8753_init(struct snd_soc_device *socdev)
1558 {
1559         struct snd_soc_codec *codec = socdev->codec;
1560         int reg, ret = 0;
1561
1562         codec->name = "WM8753";
1563         codec->owner = THIS_MODULE;
1564         codec->read = wm8753_read_reg_cache;
1565         codec->write = wm8753_write;
1566         codec->dapm_event = wm8753_dapm_event;
1567         codec->dai = wm8753_dai;
1568         codec->num_dai = 2;
1569         codec->reg_cache_size = sizeof(wm8753_reg);
1570         codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
1571
1572         if (codec->reg_cache == NULL)
1573                 return -ENOMEM;
1574
1575         wm8753_set_dai_mode(codec, 0);
1576
1577         wm8753_reset(codec);
1578
1579         /* register pcms */
1580         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
1581         if (ret < 0) {
1582                 printk(KERN_ERR "wm8753: failed to create pcms\n");
1583                 goto pcm_err;
1584         }
1585
1586         /* charge output caps */
1587         wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1588         codec->dapm_state = SNDRV_CTL_POWER_D3hot;
1589         schedule_delayed_work(&codec->delayed_work,
1590                 msecs_to_jiffies(caps_charge));
1591
1592         /* set the update bits */
1593         reg = wm8753_read_reg_cache(codec, WM8753_LDAC);
1594         wm8753_write(codec, WM8753_LDAC, reg | 0x0100);
1595         reg = wm8753_read_reg_cache(codec, WM8753_RDAC);
1596         wm8753_write(codec, WM8753_RDAC, reg | 0x0100);
1597         reg = wm8753_read_reg_cache(codec, WM8753_LADC);
1598         wm8753_write(codec, WM8753_LADC, reg | 0x0100);
1599         reg = wm8753_read_reg_cache(codec, WM8753_RADC);
1600         wm8753_write(codec, WM8753_RADC, reg | 0x0100);
1601         reg = wm8753_read_reg_cache(codec, WM8753_LOUT1V);
1602         wm8753_write(codec, WM8753_LOUT1V, reg | 0x0100);
1603         reg = wm8753_read_reg_cache(codec, WM8753_ROUT1V);
1604         wm8753_write(codec, WM8753_ROUT1V, reg | 0x0100);
1605         reg = wm8753_read_reg_cache(codec, WM8753_LOUT2V);
1606         wm8753_write(codec, WM8753_LOUT2V, reg | 0x0100);
1607         reg = wm8753_read_reg_cache(codec, WM8753_ROUT2V);
1608         wm8753_write(codec, WM8753_ROUT2V, reg | 0x0100);
1609         reg = wm8753_read_reg_cache(codec, WM8753_LINVOL);
1610         wm8753_write(codec, WM8753_LINVOL, reg | 0x0100);
1611         reg = wm8753_read_reg_cache(codec, WM8753_RINVOL);
1612         wm8753_write(codec, WM8753_RINVOL, reg | 0x0100);
1613
1614         wm8753_add_controls(codec);
1615         wm8753_add_widgets(codec);
1616         ret = snd_soc_register_card(socdev);
1617         if (ret < 0) {
1618                 printk(KERN_ERR "wm8753: failed to register card\n");
1619                 goto card_err;
1620         }
1621
1622         return ret;
1623
1624 card_err:
1625         snd_soc_free_pcms(socdev);
1626         snd_soc_dapm_free(socdev);
1627 pcm_err:
1628         kfree(codec->reg_cache);
1629         return ret;
1630 }
1631
1632 /* If the i2c layer weren't so broken, we could pass this kind of data
1633    around */
1634 static struct snd_soc_device *wm8753_socdev;
1635
1636 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1637
1638 /*
1639  * WM8753 2 wire address is determined by GPIO5
1640  * state during powerup.
1641  *    low  = 0x1a
1642  *    high = 0x1b
1643  */
1644 static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END };
1645
1646 /* Magic definition of all other variables and things */
1647 I2C_CLIENT_INSMOD;
1648
1649 static struct i2c_driver wm8753_i2c_driver;
1650 static struct i2c_client client_template;
1651
1652 static int wm8753_codec_probe(struct i2c_adapter *adap, int addr, int kind)
1653 {
1654         struct snd_soc_device *socdev = wm8753_socdev;
1655         struct wm8753_setup_data *setup = socdev->codec_data;
1656         struct snd_soc_codec *codec = socdev->codec;
1657         struct i2c_client *i2c;
1658         int ret;
1659
1660         if (addr != setup->i2c_address)
1661                 return -ENODEV;
1662
1663         client_template.adapter = adap;
1664         client_template.addr = addr;
1665
1666         i2c =  kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
1667         if (!i2c) {
1668                 kfree(codec);
1669                 return -ENOMEM;
1670         }
1671         i2c_set_clientdata(i2c, codec);
1672         codec->control_data = i2c;
1673
1674         ret = i2c_attach_client(i2c);
1675         if (ret < 0) {
1676                 err("failed to attach codec at addr %x\n", addr);
1677                 goto err;
1678         }
1679
1680         ret = wm8753_init(socdev);
1681         if (ret < 0) {
1682                 err("failed to initialise WM8753\n");
1683                 goto err;
1684         }
1685
1686         return ret;
1687
1688 err:
1689         kfree(codec);
1690         kfree(i2c);
1691         return ret;
1692 }
1693
1694 static int wm8753_i2c_detach(struct i2c_client *client)
1695 {
1696         struct snd_soc_codec *codec = i2c_get_clientdata(client);
1697         i2c_detach_client(client);
1698         kfree(codec->reg_cache);
1699         kfree(client);
1700         return 0;
1701 }
1702
1703 static int wm8753_i2c_attach(struct i2c_adapter *adap)
1704 {
1705         return i2c_probe(adap, &addr_data, wm8753_codec_probe);
1706 }
1707
1708 /* corgi i2c codec control layer */
1709 static struct i2c_driver wm8753_i2c_driver = {
1710         .driver = {
1711                 .name = "WM8753 I2C Codec",
1712                 .owner = THIS_MODULE,
1713         },
1714         .id =             I2C_DRIVERID_WM8753,
1715         .attach_adapter = wm8753_i2c_attach,
1716         .detach_client =  wm8753_i2c_detach,
1717         .command =        NULL,
1718 };
1719
1720 static struct i2c_client client_template = {
1721         .name =   "WM8753",
1722         .driver = &wm8753_i2c_driver,
1723 };
1724 #endif
1725
1726 static int wm8753_probe(struct platform_device *pdev)
1727 {
1728         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1729         struct wm8753_setup_data *setup;
1730         struct snd_soc_codec *codec;
1731         struct wm8753_priv *wm8753;
1732         int ret = 0;
1733
1734         info("WM8753 Audio Codec %s", WM8753_VERSION);
1735
1736         setup = socdev->codec_data;
1737         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
1738         if (codec == NULL)
1739                 return -ENOMEM;
1740
1741         wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
1742         if (wm8753 == NULL) {
1743                 kfree(codec);
1744                 return -ENOMEM;
1745         }
1746
1747         codec->private_data = wm8753;
1748         socdev->codec = codec;
1749         mutex_init(&codec->mutex);
1750         INIT_LIST_HEAD(&codec->dapm_widgets);
1751         INIT_LIST_HEAD(&codec->dapm_paths);
1752         wm8753_socdev = socdev;
1753         INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
1754
1755 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1756         if (setup->i2c_address) {
1757                 normal_i2c[0] = setup->i2c_address;
1758                 codec->hw_write = (hw_write_t)i2c_master_send;
1759                 ret = i2c_add_driver(&wm8753_i2c_driver);
1760                 if (ret != 0)
1761                         printk(KERN_ERR "can't add i2c driver");
1762         }
1763 #else
1764                 /* Add other interfaces here */
1765 #endif
1766         return ret;
1767 }
1768
1769 /*
1770  * This function forces any delayed work to be queued and run.
1771  */
1772 static int run_delayed_work(struct delayed_work *dwork)
1773 {
1774         int ret;
1775
1776         /* cancel any work waiting to be queued. */
1777         ret = cancel_delayed_work(dwork);
1778
1779         /* if there was any work waiting then we run it now and
1780          * wait for it's completion */
1781         if (ret) {
1782                 schedule_delayed_work(dwork, 0);
1783                 flush_scheduled_work();
1784         }
1785         return ret;
1786 }
1787
1788 /* power down chip */
1789 static int wm8753_remove(struct platform_device *pdev)
1790 {
1791         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1792         struct snd_soc_codec *codec = socdev->codec;
1793
1794         if (codec->control_data)
1795                 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1796         run_delayed_work(&codec->delayed_work);
1797         snd_soc_free_pcms(socdev);
1798         snd_soc_dapm_free(socdev);
1799 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1800         i2c_del_driver(&wm8753_i2c_driver);
1801 #endif
1802         kfree(codec->private_data);
1803         kfree(codec);
1804
1805         return 0;
1806 }
1807
1808 struct snd_soc_codec_device soc_codec_dev_wm8753 = {
1809         .probe =        wm8753_probe,
1810         .remove =       wm8753_remove,
1811         .suspend =      wm8753_suspend,
1812         .resume =       wm8753_resume,
1813 };
1814 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8753);
1815
1816 MODULE_DESCRIPTION("ASoC WM8753 driver");
1817 MODULE_AUTHOR("Liam Girdwood");
1818 MODULE_LICENSE("GPL");