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