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