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