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 struct snd_soc_dapm_route audio_map[] = {
 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
 679 static int wm8753_add_widgets(struct snd_soc_codec *codec)
 680 {
 681         snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
 682                                   ARRAY_SIZE(wm8753_dapm_widgets));
 683
 684         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 685
 686         snd_soc_dapm_new_widgets(codec);
 687         return 0;
 688 }
 689
 690 /* PLL divisors */
 691 struct _pll_div {
 692         u32 div2:1;
 693         u32 n:4;
 694         u32 k:24;
 695 };
 696
 697 /* The size in bits of the pll divide multiplied by 10
 698  * to allow rounding later */
 699 #define FIXED_PLL_SIZE ((1 << 22) * 10)
 700
 701 static void pll_factors(struct _pll_div *pll_div, unsigned int target,
 702         unsigned int source)
 703 {
 704         u64 Kpart;
 705         unsigned int K, Ndiv, Nmod;
 706
 707         Ndiv = target / source;
 708         if (Ndiv < 6) {
 709                 source >>= 1;
 710                 pll_div->div2 = 1;
 711                 Ndiv = target / source;
 712         } else
 713                 pll_div->div2 = 0;
 714
 715         if ((Ndiv < 6) || (Ndiv > 12))
 716                 printk(KERN_WARNING
 717                         "wm8753: unsupported N = %d\n", Ndiv);
 718
 719         pll_div->n = Ndiv;
 720         Nmod = target % source;
 721         Kpart = FIXED_PLL_SIZE * (long long)Nmod;
 722
 723         do_div(Kpart, source);
 724
 725         K = Kpart & 0xFFFFFFFF;
 726
 727         /* Check if we need to round */
 728         if ((K % 10) >= 5)
 729                 K += 5;
 730
 731         /* Move down to proper range now rounding is done */
 732         K /= 10;
 733
 734         pll_div->k = K;
 735 }
 736
 737 static int wm8753_set_dai_pll(struct snd_soc_codec_dai *codec_dai,
 738                 int pll_id, unsigned int freq_in, unsigned int freq_out)
 739 {
 740         u16 reg, enable;
 741         int offset;
 742         struct snd_soc_codec *codec = codec_dai->codec;
 743
 744         if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2)
 745                 return -ENODEV;
 746
 747         if (pll_id == WM8753_PLL1) {
 748                 offset = 0;
 749                 enable = 0x10;
 750                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xffef;
 751         } else {
 752                 offset = 4;
 753                 enable = 0x8;
 754                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfff7;
 755         }
 756
 757         if (!freq_in || !freq_out) {
 758                 /* disable PLL  */
 759                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0026);
 760                 wm8753_write(codec, WM8753_CLOCK, reg);
 761                 return 0;
 762         } else {
 763                 u16 value = 0;
 764                 struct _pll_div pll_div;
 765
 766                 pll_factors(&pll_div, freq_out * 8, freq_in);
 767
 768                 /* set up N and K PLL divisor ratios */
 769                 /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */
 770                 value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18);
 771                 wm8753_write(codec, WM8753_PLL1CTL2 + offset, value);
 772
 773                 /* bits 8:0 = PLL_K[17:9] */
 774                 value = (pll_div.k & 0x03fe00) >> 9;
 775                 wm8753_write(codec, WM8753_PLL1CTL3 + offset, value);
 776
 777                 /* bits 8:0 = PLL_K[8:0] */
 778                 value = pll_div.k & 0x0001ff;
 779                 wm8753_write(codec, WM8753_PLL1CTL4 + offset, value);
 780
 781                 /* set PLL as input and enable */
 782                 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 |
 783                         (pll_div.div2 << 3));
 784                 wm8753_write(codec, WM8753_CLOCK, reg | enable);
 785         }
 786         return 0;
 787 }
 788
 789 struct _coeff_div {
 790         u32 mclk;
 791         u32 rate;
 792         u8 sr:5;
 793         u8 usb:1;
 794 };
 795
 796 /* codec hifi mclk (after PLL) clock divider coefficients */
 797 static const struct _coeff_div coeff_div[] = {
 798         /* 8k */
 799         {12288000, 8000, 0x6, 0x0},
 800         {11289600, 8000, 0x16, 0x0},
 801         {18432000, 8000, 0x7, 0x0},
 802         {16934400, 8000, 0x17, 0x0},
 803         {12000000, 8000, 0x6, 0x1},
 804
 805         /* 11.025k */
 806         {11289600, 11025, 0x18, 0x0},
 807         {16934400, 11025, 0x19, 0x0},
 808         {12000000, 11025, 0x19, 0x1},
 809
 810         /* 16k */
 811         {12288000, 16000, 0xa, 0x0},
 812         {18432000, 16000, 0xb, 0x0},
 813         {12000000, 16000, 0xa, 0x1},
 814
 815         /* 22.05k */
 816         {11289600, 22050, 0x1a, 0x0},
 817         {16934400, 22050, 0x1b, 0x0},
 818         {12000000, 22050, 0x1b, 0x1},
 819
 820         /* 32k */
 821         {12288000, 32000, 0xc, 0x0},
 822         {18432000, 32000, 0xd, 0x0},
 823         {12000000, 32000, 0xa, 0x1},
 824
 825         /* 44.1k */
 826         {11289600, 44100, 0x10, 0x0},
 827         {16934400, 44100, 0x11, 0x0},
 828         {12000000, 44100, 0x11, 0x1},
 829
 830         /* 48k */
 831         {12288000, 48000, 0x0, 0x0},
 832         {18432000, 48000, 0x1, 0x0},
 833         {12000000, 48000, 0x0, 0x1},
 834
 835         /* 88.2k */
 836         {11289600, 88200, 0x1e, 0x0},
 837         {16934400, 88200, 0x1f, 0x0},
 838         {12000000, 88200, 0x1f, 0x1},
 839
 840         /* 96k */
 841         {12288000, 96000, 0xe, 0x0},
 842         {18432000, 96000, 0xf, 0x0},
 843         {12000000, 96000, 0xe, 0x1},
 844 };
 845
 846 static int get_coeff(int mclk, int rate)
 847 {
 848         int i;
 849
 850         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
 851                 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
 852                         return i;
 853         }
 854         return -EINVAL;
 855 }
 856
 857 /*
 858  * Clock after PLL and dividers
 859  */
 860 static int wm8753_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai,
 861                 int clk_id, unsigned int freq, int dir)
 862 {
 863         struct snd_soc_codec *codec = codec_dai->codec;
 864         struct wm8753_priv *wm8753 = codec->private_data;
 865
 866         switch (freq) {
 867         case 11289600:
 868         case 12000000:
 869         case 12288000:
 870         case 16934400:
 871         case 18432000:
 872                 if (clk_id == WM8753_MCLK) {
 873                         wm8753->sysclk = freq;
 874                         return 0;
 875                 } else if (clk_id == WM8753_PCMCLK) {
 876                         wm8753->pcmclk = freq;
 877                         return 0;
 878                 }
 879                 break;
 880         }
 881         return -EINVAL;
 882 }
 883
 884 /*
 885  * Set's ADC and Voice DAC format.
 886  */
 887 static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 888                 unsigned int fmt)
 889 {
 890         struct snd_soc_codec *codec = codec_dai->codec;
 891         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01ec;
 892
 893         /* interface format */
 894         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 895         case SND_SOC_DAIFMT_I2S:
 896                 voice |= 0x0002;
 897                 break;
 898         case SND_SOC_DAIFMT_RIGHT_J:
 899                 break;
 900         case SND_SOC_DAIFMT_LEFT_J:
 901                 voice |= 0x0001;
 902                 break;
 903         case SND_SOC_DAIFMT_DSP_A:
 904                 voice |= 0x0003;
 905                 break;
 906         case SND_SOC_DAIFMT_DSP_B:
 907                 voice |= 0x0013;
 908                 break;
 909         default:
 910                 return -EINVAL;
 911         }
 912
 913         wm8753_write(codec, WM8753_PCM, voice);
 914         return 0;
 915 }
 916
 917 /*
 918  * Set PCM DAI bit size and sample rate.
 919  */
 920 static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream,
 921         struct snd_pcm_hw_params *params)
 922 {
 923         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 924         struct snd_soc_device *socdev = rtd->socdev;
 925         struct snd_soc_codec *codec = socdev->codec;
 926         struct wm8753_priv *wm8753 = codec->private_data;
 927         u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01f3;
 928         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x017f;
 929
 930         /* bit size */
 931         switch (params_format(params)) {
 932         case SNDRV_PCM_FORMAT_S16_LE:
 933                 break;
 934         case SNDRV_PCM_FORMAT_S20_3LE:
 935                 voice |= 0x0004;
 936                 break;
 937         case SNDRV_PCM_FORMAT_S24_LE:
 938                 voice |= 0x0008;
 939                 break;
 940         case SNDRV_PCM_FORMAT_S32_LE:
 941                 voice |= 0x000c;
 942                 break;
 943         }
 944
 945         /* sample rate */
 946         if (params_rate(params) * 384 == wm8753->pcmclk)
 947                 srate |= 0x80;
 948         wm8753_write(codec, WM8753_SRATE1, srate);
 949
 950         wm8753_write(codec, WM8753_PCM, voice);
 951         return 0;
 952 }
 953
 954 /*
 955  * Set's PCM dai fmt and BCLK.
 956  */
 957 static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
 958                 unsigned int fmt)
 959 {
 960         struct snd_soc_codec *codec = codec_dai->codec;
 961         u16 voice, ioctl;
 962
 963         voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x011f;
 964         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x015d;
 965
 966         /* set master/slave audio interface */
 967         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 968         case SND_SOC_DAIFMT_CBS_CFS:
 969                 break;
 970         case SND_SOC_DAIFMT_CBM_CFM:
 971                 ioctl |= 0x2;
 972         case SND_SOC_DAIFMT_CBM_CFS:
 973                 voice |= 0x0040;
 974                 break;
 975         default:
 976                 return -EINVAL;
 977         }
 978
 979         /* clock inversion */
 980         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 981         case SND_SOC_DAIFMT_DSP_A:
 982         case SND_SOC_DAIFMT_DSP_B:
 983                 /* frame inversion not valid for DSP modes */
 984                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 985                 case SND_SOC_DAIFMT_NB_NF:
 986                         break;
 987                 case SND_SOC_DAIFMT_IB_NF:
 988                         voice |= 0x0080;
 989                         break;
 990                 default:
 991                         return -EINVAL;
 992                 }
 993                 break;
 994         case SND_SOC_DAIFMT_I2S:
 995         case SND_SOC_DAIFMT_RIGHT_J:
 996         case SND_SOC_DAIFMT_LEFT_J:
 997                 voice &= ~0x0010;
 998                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 999                 case SND_SOC_DAIFMT_NB_NF:
1000                         break;
1001                 case SND_SOC_DAIFMT_IB_IF:
1002                         voice |= 0x0090;
1003                         break;
1004                 case SND_SOC_DAIFMT_IB_NF:
1005                         voice |= 0x0080;
1006                         break;
1007                 case SND_SOC_DAIFMT_NB_IF:
1008                         voice |= 0x0010;
1009                         break;
1010                 default:
1011                         return -EINVAL;
1012                 }
1013                 break;
1014         default:
1015                 return -EINVAL;
1016         }
1017
1018         wm8753_write(codec, WM8753_PCM, voice);
1019         wm8753_write(codec, WM8753_IOCTL, ioctl);
1020         return 0;
1021 }
1022
1023 static int wm8753_set_dai_clkdiv(struct snd_soc_codec_dai *codec_dai,
1024                 int div_id, int div)
1025 {
1026         struct snd_soc_codec *codec = codec_dai->codec;
1027         u16 reg;
1028
1029         switch (div_id) {
1030         case WM8753_PCMDIV:
1031                 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0x003f;
1032                 wm8753_write(codec, WM8753_CLOCK, reg | div);
1033                 break;
1034         case WM8753_BCLKDIV:
1035                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x01c7;
1036                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1037                 break;
1038         case WM8753_VXCLKDIV:
1039                 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x003f;
1040                 wm8753_write(codec, WM8753_SRATE2, reg | div);
1041                 break;
1042         default:
1043                 return -EINVAL;
1044         }
1045         return 0;
1046 }
1047
1048 /*
1049  * Set's HiFi DAC format.
1050  */
1051 static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1052                 unsigned int fmt)
1053 {
1054         struct snd_soc_codec *codec = codec_dai->codec;
1055         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01e0;
1056
1057         /* interface format */
1058         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1059         case SND_SOC_DAIFMT_I2S:
1060                 hifi |= 0x0002;
1061                 break;
1062         case SND_SOC_DAIFMT_RIGHT_J:
1063                 break;
1064         case SND_SOC_DAIFMT_LEFT_J:
1065                 hifi |= 0x0001;
1066                 break;
1067         case SND_SOC_DAIFMT_DSP_A:
1068                 hifi |= 0x0003;
1069                 break;
1070         case SND_SOC_DAIFMT_DSP_B:
1071                 hifi |= 0x0013;
1072                 break;
1073         default:
1074                 return -EINVAL;
1075         }
1076
1077         wm8753_write(codec, WM8753_HIFI, hifi);
1078         return 0;
1079 }
1080
1081 /*
1082  * Set's I2S DAI format.
1083  */
1084 static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1085                 unsigned int fmt)
1086 {
1087         struct snd_soc_codec *codec = codec_dai->codec;
1088         u16 ioctl, hifi;
1089
1090         hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x011f;
1091         ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x00ae;
1092
1093         /* set master/slave audio interface */
1094         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1095         case SND_SOC_DAIFMT_CBS_CFS:
1096                 break;
1097         case SND_SOC_DAIFMT_CBM_CFM:
1098                 ioctl |= 0x1;
1099         case SND_SOC_DAIFMT_CBM_CFS:
1100                 hifi |= 0x0040;
1101                 break;
1102         default:
1103                 return -EINVAL;
1104         }
1105
1106         /* clock inversion */
1107         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1108         case SND_SOC_DAIFMT_DSP_A:
1109         case SND_SOC_DAIFMT_DSP_B:
1110                 /* frame inversion not valid for DSP modes */
1111                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1112                 case SND_SOC_DAIFMT_NB_NF:
1113                         break;
1114                 case SND_SOC_DAIFMT_IB_NF:
1115                         hifi |= 0x0080;
1116                         break;
1117                 default:
1118                         return -EINVAL;
1119                 }
1120                 break;
1121         case SND_SOC_DAIFMT_I2S:
1122         case SND_SOC_DAIFMT_RIGHT_J:
1123         case SND_SOC_DAIFMT_LEFT_J:
1124                 hifi &= ~0x0010;
1125                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1126                 case SND_SOC_DAIFMT_NB_NF:
1127                         break;
1128                 case SND_SOC_DAIFMT_IB_IF:
1129                         hifi |= 0x0090;
1130                         break;
1131                 case SND_SOC_DAIFMT_IB_NF:
1132                         hifi |= 0x0080;
1133                         break;
1134                 case SND_SOC_DAIFMT_NB_IF:
1135                         hifi |= 0x0010;
1136                         break;
1137                 default:
1138                         return -EINVAL;
1139                 }
1140                 break;
1141         default:
1142                 return -EINVAL;
1143         }
1144
1145         wm8753_write(codec, WM8753_HIFI, hifi);
1146         wm8753_write(codec, WM8753_IOCTL, ioctl);
1147         return 0;
1148 }
1149
1150 /*
1151  * Set PCM DAI bit size and sample rate.
1152  */
1153 static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream,
1154         struct snd_pcm_hw_params *params)
1155 {
1156         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1157         struct snd_soc_device *socdev = rtd->socdev;
1158         struct snd_soc_codec *codec = socdev->codec;
1159         struct wm8753_priv *wm8753 = codec->private_data;
1160         u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x01c0;
1161         u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01f3;
1162         int coeff;
1163
1164         /* is digital filter coefficient valid ? */
1165         coeff = get_coeff(wm8753->sysclk, params_rate(params));
1166         if (coeff < 0) {
1167                 printk(KERN_ERR "wm8753 invalid MCLK or rate\n");
1168                 return coeff;
1169         }
1170         wm8753_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) |
1171                 coeff_div[coeff].usb);
1172
1173         /* bit size */
1174         switch (params_format(params)) {
1175         case SNDRV_PCM_FORMAT_S16_LE:
1176                 break;
1177         case SNDRV_PCM_FORMAT_S20_3LE:
1178                 hifi |= 0x0004;
1179                 break;
1180         case SNDRV_PCM_FORMAT_S24_LE:
1181                 hifi |= 0x0008;
1182                 break;
1183         case SNDRV_PCM_FORMAT_S32_LE:
1184                 hifi |= 0x000c;
1185                 break;
1186         }
1187
1188         wm8753_write(codec, WM8753_HIFI, hifi);
1189         return 0;
1190 }
1191
1192 static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1193                 unsigned int fmt)
1194 {
1195         struct snd_soc_codec *codec = codec_dai->codec;
1196         u16 clock;
1197
1198         /* set clk source as pcmclk */
1199         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1200         wm8753_write(codec, WM8753_CLOCK, clock);
1201
1202         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1203                 return -EINVAL;
1204         return wm8753_pcm_set_dai_fmt(codec_dai, fmt);
1205 }
1206
1207 static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1208                 unsigned int fmt)
1209 {
1210         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1211                 return -EINVAL;
1212         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1213 }
1214
1215 static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1216                 unsigned int fmt)
1217 {
1218         struct snd_soc_codec *codec = codec_dai->codec;
1219         u16 clock;
1220
1221         /* set clk source as pcmclk */
1222         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1223         wm8753_write(codec, WM8753_CLOCK, clock);
1224
1225         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1226                 return -EINVAL;
1227         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1228 }
1229
1230 static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1231                 unsigned int fmt)
1232 {
1233         struct snd_soc_codec *codec = codec_dai->codec;
1234         u16 clock;
1235
1236         /* set clk source as mclk */
1237         clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1238         wm8753_write(codec, WM8753_CLOCK, clock | 0x4);
1239
1240         if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1241                 return -EINVAL;
1242         if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1243                 return -EINVAL;
1244         return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1245 }
1246
1247 static int wm8753_mute(struct snd_soc_codec_dai *dai, int mute)
1248 {
1249         struct snd_soc_codec *codec = dai->codec;
1250         u16 mute_reg = wm8753_read_reg_cache(codec, WM8753_DAC) & 0xfff7;
1251
1252         /* the digital mute covers the HiFi and Voice DAC's on the WM8753.
1253          * make sure we check if they are not both active when we mute */
1254         if (mute && dai->id == 1) {
1255                 if (!wm8753_dai[WM8753_DAI_VOICE].playback.active ||
1256                         !wm8753_dai[WM8753_DAI_HIFI].playback.active)
1257                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1258         } else {
1259                 if (mute)
1260                         wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1261                 else
1262                         wm8753_write(codec, WM8753_DAC, mute_reg);
1263         }
1264
1265         return 0;
1266 }
1267
1268 static int wm8753_set_bias_level(struct snd_soc_codec *codec,
1269                                  enum snd_soc_bias_level level)
1270 {
1271         u16 pwr_reg = wm8753_read_reg_cache(codec, WM8753_PWR1) & 0xfe3e;
1272
1273         switch (level) {
1274         case SND_SOC_BIAS_ON:
1275                 /* set vmid to 50k and unmute dac */
1276                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
1277                 break;
1278         case SND_SOC_BIAS_PREPARE:
1279                 /* set vmid to 5k for quick power up */
1280                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
1281                 break;
1282         case SND_SOC_BIAS_STANDBY:
1283                 /* mute dac and set vmid to 500k, enable VREF */
1284                 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
1285                 break;
1286         case SND_SOC_BIAS_OFF:
1287                 wm8753_write(codec, WM8753_PWR1, 0x0001);
1288                 break;
1289         }
1290         codec->bias_level = level;
1291         return 0;
1292 }
1293
1294 #define WM8753_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
1295                 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
1296                 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
1297                 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
1298
1299 #define WM8753_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1300         SNDRV_PCM_FMTBIT_S24_LE)
1301
1302 /*
1303  * The WM8753 supports upto 4 different and mutually exclusive DAI
1304  * configurations. This gives 2 PCM's available for use, hifi and voice.
1305  * NOTE: The Voice PCM cannot play or capture audio to the CPU as it's DAI
1306  * is connected between the wm8753 and a BT codec or GSM modem.
1307  *
1308  * 1. Voice over PCM DAI - HIFI DAC over HIFI DAI
1309  * 2. Voice over HIFI DAI - HIFI disabled
1310  * 3. Voice disabled - HIFI over HIFI
1311  * 4. Voice disabled - HIFI over HIFI, uses voice DAI LRC for capture
1312  */
1313 static const struct snd_soc_codec_dai wm8753_all_dai[] = {
1314 /* DAI HiFi mode 1 */
1315 {       .name = "WM8753 HiFi",
1316         .id = 1,
1317         .playback = {
1318                 .stream_name = "HiFi Playback",
1319                 .channels_min = 1,
1320                 .channels_max = 2,
1321                 .rates = WM8753_RATES,
1322                 .formats = WM8753_FORMATS,},
1323         .capture = { /* dummy for fast DAI switching */
1324                 .stream_name = "Capture",
1325                 .channels_min = 1,
1326                 .channels_max = 2,
1327                 .rates = WM8753_RATES,
1328                 .formats = WM8753_FORMATS,},
1329         .ops = {
1330                 .hw_params = wm8753_i2s_hw_params,},
1331         .dai_ops = {
1332                 .digital_mute = wm8753_mute,
1333                 .set_fmt = wm8753_mode1h_set_dai_fmt,
1334                 .set_clkdiv = wm8753_set_dai_clkdiv,
1335                 .set_pll = wm8753_set_dai_pll,
1336                 .set_sysclk = wm8753_set_dai_sysclk,
1337         },
1338 },
1339 /* DAI Voice mode 1 */
1340 {       .name = "WM8753 Voice",
1341         .id = 1,
1342         .playback = {
1343                 .stream_name = "Voice Playback",
1344                 .channels_min = 1,
1345                 .channels_max = 1,
1346                 .rates = WM8753_RATES,
1347                 .formats = WM8753_FORMATS,},
1348         .capture = {
1349                 .stream_name = "Capture",
1350                 .channels_min = 1,
1351                 .channels_max = 2,
1352                 .rates = WM8753_RATES,
1353                 .formats = WM8753_FORMATS,},
1354         .ops = {
1355                 .hw_params = wm8753_pcm_hw_params,},
1356         .dai_ops = {
1357                 .digital_mute = wm8753_mute,
1358                 .set_fmt = wm8753_mode1v_set_dai_fmt,
1359                 .set_clkdiv = wm8753_set_dai_clkdiv,
1360                 .set_pll = wm8753_set_dai_pll,
1361                 .set_sysclk = wm8753_set_dai_sysclk,
1362         },
1363 },
1364 /* DAI HiFi mode 2 - dummy */
1365 {       .name = "WM8753 HiFi",
1366         .id = 2,
1367 },
1368 /* DAI Voice mode 2 */
1369 {       .name = "WM8753 Voice",
1370         .id = 2,
1371         .playback = {
1372                 .stream_name = "Voice Playback",
1373                 .channels_min = 1,
1374                 .channels_max = 1,
1375                 .rates = WM8753_RATES,
1376                 .formats = WM8753_FORMATS,},
1377         .capture = {
1378                 .stream_name = "Capture",
1379                 .channels_min = 1,
1380                 .channels_max = 2,
1381                 .rates = WM8753_RATES,
1382                 .formats = WM8753_FORMATS,},
1383         .ops = {
1384                 .hw_params = wm8753_pcm_hw_params,},
1385         .dai_ops = {
1386                 .digital_mute = wm8753_mute,
1387                 .set_fmt = wm8753_mode2_set_dai_fmt,
1388                 .set_clkdiv = wm8753_set_dai_clkdiv,
1389                 .set_pll = wm8753_set_dai_pll,
1390                 .set_sysclk = wm8753_set_dai_sysclk,
1391         },
1392 },
1393 /* DAI HiFi mode 3 */
1394 {       .name = "WM8753 HiFi",
1395         .id = 3,
1396         .playback = {
1397                 .stream_name = "HiFi Playback",
1398                 .channels_min = 1,
1399                 .channels_max = 2,
1400                 .rates = WM8753_RATES,
1401                 .formats = WM8753_FORMATS,},
1402         .capture = {
1403                 .stream_name = "Capture",
1404                 .channels_min = 1,
1405                 .channels_max = 2,
1406                 .rates = WM8753_RATES,
1407                 .formats = WM8753_FORMATS,},
1408         .ops = {
1409                 .hw_params = wm8753_i2s_hw_params,},
1410         .dai_ops = {
1411                 .digital_mute = wm8753_mute,
1412                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1413                 .set_clkdiv = wm8753_set_dai_clkdiv,
1414                 .set_pll = wm8753_set_dai_pll,
1415                 .set_sysclk = wm8753_set_dai_sysclk,
1416         },
1417 },
1418 /* DAI Voice mode 3 - dummy */
1419 {       .name = "WM8753 Voice",
1420         .id = 3,
1421 },
1422 /* DAI HiFi mode 4 */
1423 {       .name = "WM8753 HiFi",
1424         .id = 4,
1425         .playback = {
1426                 .stream_name = "HiFi Playback",
1427                 .channels_min = 1,
1428                 .channels_max = 2,
1429                 .rates = WM8753_RATES,
1430                 .formats = WM8753_FORMATS,},
1431         .capture = {
1432                 .stream_name = "Capture",
1433                 .channels_min = 1,
1434                 .channels_max = 2,
1435                 .rates = WM8753_RATES,
1436                 .formats = WM8753_FORMATS,},
1437         .ops = {
1438                 .hw_params = wm8753_i2s_hw_params,},
1439         .dai_ops = {
1440                 .digital_mute = wm8753_mute,
1441                 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1442                 .set_clkdiv = wm8753_set_dai_clkdiv,
1443                 .set_pll = wm8753_set_dai_pll,
1444                 .set_sysclk = wm8753_set_dai_sysclk,
1445         },
1446 },
1447 /* DAI Voice mode 4 - dummy */
1448 {       .name = "WM8753 Voice",
1449         .id = 4,
1450 },
1451 };
1452
1453 struct snd_soc_codec_dai wm8753_dai[2];
1454 EXPORT_SYMBOL_GPL(wm8753_dai);
1455
1456 static void wm8753_set_dai_mode(struct snd_soc_codec *codec, unsigned int mode)
1457 {
1458         if (mode < 4) {
1459                 int playback_active, capture_active, codec_active, pop_wait;
1460                 void *private_data;
1461
1462                 playback_active = wm8753_dai[0].playback.active;
1463                 capture_active = wm8753_dai[0].capture.active;
1464                 codec_active = wm8753_dai[0].active;
1465                 private_data = wm8753_dai[0].private_data;
1466                 pop_wait = wm8753_dai[0].pop_wait;
1467                 wm8753_dai[0] = wm8753_all_dai[mode << 1];
1468                 wm8753_dai[0].playback.active = playback_active;
1469                 wm8753_dai[0].capture.active = capture_active;
1470                 wm8753_dai[0].active = codec_active;
1471                 wm8753_dai[0].private_data = private_data;
1472                 wm8753_dai[0].pop_wait = pop_wait;
1473
1474                 playback_active = wm8753_dai[1].playback.active;
1475                 capture_active = wm8753_dai[1].capture.active;
1476                 codec_active = wm8753_dai[1].active;
1477                 private_data = wm8753_dai[1].private_data;
1478                 pop_wait = wm8753_dai[1].pop_wait;
1479                 wm8753_dai[1] = wm8753_all_dai[(mode << 1) + 1];
1480                 wm8753_dai[1].playback.active = playback_active;
1481                 wm8753_dai[1].capture.active = capture_active;
1482                 wm8753_dai[1].active = codec_active;
1483                 wm8753_dai[1].private_data = private_data;
1484                 wm8753_dai[1].pop_wait = pop_wait;
1485         }
1486         wm8753_dai[0].codec = codec;
1487         wm8753_dai[1].codec = codec;
1488 }
1489
1490 static void wm8753_work(struct work_struct *work)
1491 {
1492         struct snd_soc_codec *codec =
1493                 container_of(work, struct snd_soc_codec, delayed_work.work);
1494         wm8753_set_bias_level(codec, codec->bias_level);
1495 }
1496
1497 static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
1498 {
1499         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1500         struct snd_soc_codec *codec = socdev->codec;
1501
1502         /* we only need to suspend if we are a valid card */
1503         if (!codec->card)
1504                 return 0;
1505
1506         wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
1507         return 0;
1508 }
1509
1510 static int wm8753_resume(struct platform_device *pdev)
1511 {
1512         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1513         struct snd_soc_codec *codec = socdev->codec;
1514         int i;
1515         u8 data[2];
1516         u16 *cache = codec->reg_cache;
1517
1518         /* we only need to resume if we are a valid card */
1519         if (!codec->card)
1520                 return 0;
1521
1522         /* Sync reg_cache with the hardware */
1523         for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
1524                 if (i + 1 == WM8753_RESET)
1525                         continue;
1526                 data[0] = ((i + 1) << 1) | ((cache[i] >> 8) & 0x0001);
1527                 data[1] = cache[i] & 0x00ff;
1528                 codec->hw_write(codec->control_data, data, 2);
1529         }
1530
1531         wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1532
1533         /* charge wm8753 caps */
1534         if (codec->suspend_bias_level == SND_SOC_BIAS_ON) {
1535                 wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
1536                 codec->bias_level = SND_SOC_BIAS_ON;
1537                 schedule_delayed_work(&codec->delayed_work,
1538                         msecs_to_jiffies(caps_charge));
1539         }
1540
1541         return 0;
1542 }
1543
1544 /*
1545  * initialise the WM8753 driver
1546  * register the mixer and dsp interfaces with the kernel
1547  */
1548 static int wm8753_init(struct snd_soc_device *socdev)
1549 {
1550         struct snd_soc_codec *codec = socdev->codec;
1551         int reg, ret = 0;
1552
1553         codec->name = "WM8753";
1554         codec->owner = THIS_MODULE;
1555         codec->read = wm8753_read_reg_cache;
1556         codec->write = wm8753_write;
1557         codec->set_bias_level = wm8753_set_bias_level;
1558         codec->dai = wm8753_dai;
1559         codec->num_dai = 2;
1560         codec->reg_cache_size = ARRAY_SIZE(wm8753_reg);
1561         codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
1562
1563         if (codec->reg_cache == NULL)
1564                 return -ENOMEM;
1565
1566         wm8753_set_dai_mode(codec, 0);
1567
1568         wm8753_reset(codec);
1569
1570         /* register pcms */
1571         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
1572         if (ret < 0) {
1573                 printk(KERN_ERR "wm8753: failed to create pcms\n");
1574                 goto pcm_err;
1575         }
1576
1577         /* charge output caps */
1578         wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
1579         codec->bias_level = SND_SOC_BIAS_STANDBY;
1580         schedule_delayed_work(&codec->delayed_work,
1581                 msecs_to_jiffies(caps_charge));
1582
1583         /* set the update bits */
1584         reg = wm8753_read_reg_cache(codec, WM8753_LDAC);
1585         wm8753_write(codec, WM8753_LDAC, reg | 0x0100);
1586         reg = wm8753_read_reg_cache(codec, WM8753_RDAC);
1587         wm8753_write(codec, WM8753_RDAC, reg | 0x0100);
1588         reg = wm8753_read_reg_cache(codec, WM8753_LADC);
1589         wm8753_write(codec, WM8753_LADC, reg | 0x0100);
1590         reg = wm8753_read_reg_cache(codec, WM8753_RADC);
1591         wm8753_write(codec, WM8753_RADC, reg | 0x0100);
1592         reg = wm8753_read_reg_cache(codec, WM8753_LOUT1V);
1593         wm8753_write(codec, WM8753_LOUT1V, reg | 0x0100);
1594         reg = wm8753_read_reg_cache(codec, WM8753_ROUT1V);
1595         wm8753_write(codec, WM8753_ROUT1V, reg | 0x0100);
1596         reg = wm8753_read_reg_cache(codec, WM8753_LOUT2V);
1597         wm8753_write(codec, WM8753_LOUT2V, reg | 0x0100);
1598         reg = wm8753_read_reg_cache(codec, WM8753_ROUT2V);
1599         wm8753_write(codec, WM8753_ROUT2V, reg | 0x0100);
1600         reg = wm8753_read_reg_cache(codec, WM8753_LINVOL);
1601         wm8753_write(codec, WM8753_LINVOL, reg | 0x0100);
1602         reg = wm8753_read_reg_cache(codec, WM8753_RINVOL);
1603         wm8753_write(codec, WM8753_RINVOL, reg | 0x0100);
1604
1605         wm8753_add_controls(codec);
1606         wm8753_add_widgets(codec);
1607         ret = snd_soc_register_card(socdev);
1608         if (ret < 0) {
1609                 printk(KERN_ERR "wm8753: failed to register card\n");
1610                 goto card_err;
1611         }
1612
1613         return ret;
1614
1615 card_err:
1616         snd_soc_free_pcms(socdev);
1617         snd_soc_dapm_free(socdev);
1618 pcm_err:
1619         kfree(codec->reg_cache);
1620         return ret;
1621 }
1622
1623 /* If the i2c layer weren't so broken, we could pass this kind of data
1624    around */
1625 static struct snd_soc_device *wm8753_socdev;
1626
1627 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1628
1629 /*
1630  * WM8753 2 wire address is determined by GPIO5
1631  * state during powerup.
1632  *    low  = 0x1a
1633  *    high = 0x1b
1634  */
1635 static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END };
1636
1637 /* Magic definition of all other variables and things */
1638 I2C_CLIENT_INSMOD;
1639
1640 static struct i2c_driver wm8753_i2c_driver;
1641 static struct i2c_client client_template;
1642
1643 static int wm8753_codec_probe(struct i2c_adapter *adap, int addr, int kind)
1644 {
1645         struct snd_soc_device *socdev = wm8753_socdev;
1646         struct wm8753_setup_data *setup = socdev->codec_data;
1647         struct snd_soc_codec *codec = socdev->codec;
1648         struct i2c_client *i2c;
1649         int ret;
1650
1651         if (addr != setup->i2c_address)
1652                 return -ENODEV;
1653
1654         client_template.adapter = adap;
1655         client_template.addr = addr;
1656
1657         i2c =  kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
1658         if (!i2c) {
1659                 kfree(codec);
1660                 return -ENOMEM;
1661         }
1662         i2c_set_clientdata(i2c, codec);
1663         codec->control_data = i2c;
1664
1665         ret = i2c_attach_client(i2c);
1666         if (ret < 0) {
1667                 err("failed to attach codec at addr %x\n", addr);
1668                 goto err;
1669         }
1670
1671         ret = wm8753_init(socdev);
1672         if (ret < 0) {
1673                 err("failed to initialise WM8753\n");
1674                 goto err;
1675         }
1676
1677         return ret;
1678
1679 err:
1680         kfree(codec);
1681         kfree(i2c);
1682         return ret;
1683 }
1684
1685 static int wm8753_i2c_detach(struct i2c_client *client)
1686 {
1687         struct snd_soc_codec *codec = i2c_get_clientdata(client);
1688         i2c_detach_client(client);
1689         kfree(codec->reg_cache);
1690         kfree(client);
1691         return 0;
1692 }
1693
1694 static int wm8753_i2c_attach(struct i2c_adapter *adap)
1695 {
1696         return i2c_probe(adap, &addr_data, wm8753_codec_probe);
1697 }
1698
1699 /* corgi i2c codec control layer */
1700 static struct i2c_driver wm8753_i2c_driver = {
1701         .driver = {
1702                 .name = "WM8753 I2C Codec",
1703                 .owner = THIS_MODULE,
1704         },
1705         .id =             I2C_DRIVERID_WM8753,
1706         .attach_adapter = wm8753_i2c_attach,
1707         .detach_client =  wm8753_i2c_detach,
1708         .command =        NULL,
1709 };
1710
1711 static struct i2c_client client_template = {
1712         .name =   "WM8753",
1713         .driver = &wm8753_i2c_driver,
1714 };
1715 #endif
1716
1717 static int wm8753_probe(struct platform_device *pdev)
1718 {
1719         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1720         struct wm8753_setup_data *setup;
1721         struct snd_soc_codec *codec;
1722         struct wm8753_priv *wm8753;
1723         int ret = 0;
1724
1725         info("WM8753 Audio Codec %s", WM8753_VERSION);
1726
1727         setup = socdev->codec_data;
1728         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
1729         if (codec == NULL)
1730                 return -ENOMEM;
1731
1732         wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
1733         if (wm8753 == NULL) {
1734                 kfree(codec);
1735                 return -ENOMEM;
1736         }
1737
1738         codec->private_data = wm8753;
1739         socdev->codec = codec;
1740         mutex_init(&codec->mutex);
1741         INIT_LIST_HEAD(&codec->dapm_widgets);
1742         INIT_LIST_HEAD(&codec->dapm_paths);
1743         wm8753_socdev = socdev;
1744         INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
1745
1746 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1747         if (setup->i2c_address) {
1748                 normal_i2c[0] = setup->i2c_address;
1749                 codec->hw_write = (hw_write_t)i2c_master_send;
1750                 ret = i2c_add_driver(&wm8753_i2c_driver);
1751                 if (ret != 0)
1752                         printk(KERN_ERR "can't add i2c driver");
1753         }
1754 #else
1755                 /* Add other interfaces here */
1756 #endif
1757         return ret;
1758 }
1759
1760 /*
1761  * This function forces any delayed work to be queued and run.
1762  */
1763 static int run_delayed_work(struct delayed_work *dwork)
1764 {
1765         int ret;
1766
1767         /* cancel any work waiting to be queued. */
1768         ret = cancel_delayed_work(dwork);
1769
1770         /* if there was any work waiting then we run it now and
1771          * wait for it's completion */
1772         if (ret) {
1773                 schedule_delayed_work(dwork, 0);
1774                 flush_scheduled_work();
1775         }
1776         return ret;
1777 }
1778
1779 /* power down chip */
1780 static int wm8753_remove(struct platform_device *pdev)
1781 {
1782         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1783         struct snd_soc_codec *codec = socdev->codec;
1784
1785         if (codec->control_data)
1786                 wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
1787         run_delayed_work(&codec->delayed_work);
1788         snd_soc_free_pcms(socdev);
1789         snd_soc_dapm_free(socdev);
1790 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1791         i2c_del_driver(&wm8753_i2c_driver);
1792 #endif
1793         kfree(codec->private_data);
1794         kfree(codec);
1795
1796         return 0;
1797 }
1798
1799 struct snd_soc_codec_device soc_codec_dev_wm8753 = {
1800         .probe =        wm8753_probe,
1801         .remove =       wm8753_remove,
1802         .suspend =      wm8753_suspend,
1803         .resume =       wm8753_resume,
1804 };
1805 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8753);
1806
1807 MODULE_DESCRIPTION("ASoC WM8753 driver");
1808 MODULE_AUTHOR("Liam Girdwood");
1809 MODULE_LICENSE("GPL");