1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * DA7213 ALSA SoC Codec Driver 4 * 5 * Copyright (c) 2013 Dialog Semiconductor 6 * 7 * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com> 8 * Based on DA9055 ALSA SoC codec driver. 9 */ 10 11 #include <linux/acpi.h> 12 #include <linux/of.h> 13 #include <linux/property.h> 14 #include <linux/cleanup.h> 15 #include <linux/clk.h> 16 #include <linux/delay.h> 17 #include <linux/i2c.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 #include <linux/module.h> 21 #include <sound/pcm.h> 22 #include <sound/pcm_params.h> 23 #include <linux/pm_runtime.h> 24 #include <linux/units.h> 25 #include <sound/soc.h> 26 #include <sound/initval.h> 27 #include <sound/tlv.h> 28 29 #include <sound/da7213.h> 30 #include "da7213.h" 31 32 33 /* Gain and Volume */ 34 static const DECLARE_TLV_DB_RANGE(aux_vol_tlv, 35 /* -54dB */ 36 0x0, 0x11, TLV_DB_SCALE_ITEM(-5400, 0, 0), 37 /* -52.5dB to 15dB */ 38 0x12, 0x3f, TLV_DB_SCALE_ITEM(-5250, 150, 0) 39 ); 40 41 static const DECLARE_TLV_DB_RANGE(digital_gain_tlv, 42 0x0, 0x07, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 1), 43 /* -78dB to 12dB */ 44 0x08, 0x7f, TLV_DB_SCALE_ITEM(-7800, 75, 0) 45 ); 46 47 static const DECLARE_TLV_DB_RANGE(alc_analog_gain_tlv, 48 0x0, 0x0, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 1), 49 /* 0dB to 36dB */ 50 0x01, 0x07, TLV_DB_SCALE_ITEM(0, 600, 0) 51 ); 52 53 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -600, 600, 0); 54 static const DECLARE_TLV_DB_SCALE(mixin_gain_tlv, -450, 150, 0); 55 static const DECLARE_TLV_DB_SCALE(eq_gain_tlv, -1050, 150, 0); 56 static const DECLARE_TLV_DB_SCALE(hp_vol_tlv, -5700, 100, 0); 57 static const DECLARE_TLV_DB_SCALE(lineout_vol_tlv, -4800, 100, 0); 58 static const DECLARE_TLV_DB_SCALE(alc_threshold_tlv, -9450, 150, 0); 59 static const DECLARE_TLV_DB_SCALE(alc_gain_tlv, 0, 600, 0); 60 static const DECLARE_TLV_DB_SCALE(da7213_tonegen_gain_tlv, -4500, 300, 0); 61 62 /* ADC and DAC voice mode (8kHz) high pass cutoff value */ 63 static const char * const da7213_voice_hpf_corner_txt[] = { 64 "2.5Hz", "25Hz", "50Hz", "100Hz", "150Hz", "200Hz", "300Hz", "400Hz" 65 }; 66 67 static SOC_ENUM_SINGLE_DECL(da7213_dac_voice_hpf_corner, 68 DA7213_DAC_FILTERS1, 69 DA7213_VOICE_HPF_CORNER_SHIFT, 70 da7213_voice_hpf_corner_txt); 71 72 static SOC_ENUM_SINGLE_DECL(da7213_adc_voice_hpf_corner, 73 DA7213_ADC_FILTERS1, 74 DA7213_VOICE_HPF_CORNER_SHIFT, 75 da7213_voice_hpf_corner_txt); 76 77 /* ADC and DAC high pass filter cutoff value */ 78 static const char * const da7213_audio_hpf_corner_txt[] = { 79 "Fs/24000", "Fs/12000", "Fs/6000", "Fs/3000" 80 }; 81 82 static SOC_ENUM_SINGLE_DECL(da7213_dac_audio_hpf_corner, 83 DA7213_DAC_FILTERS1, 84 DA7213_AUDIO_HPF_CORNER_SHIFT, 85 da7213_audio_hpf_corner_txt); 86 87 static SOC_ENUM_SINGLE_DECL(da7213_adc_audio_hpf_corner, 88 DA7213_ADC_FILTERS1, 89 DA7213_AUDIO_HPF_CORNER_SHIFT, 90 da7213_audio_hpf_corner_txt); 91 92 static const char * const da7213_tonegen_dtmf_key_txt[] = { 93 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", 94 "*", "#" 95 }; 96 97 static const struct soc_enum da7213_tonegen_dtmf_key = 98 SOC_ENUM_SINGLE(DA7213_TONE_GEN_CFG1, DA7213_DTMF_REG_SHIFT, 99 DA7213_DTMF_REG_MAX, da7213_tonegen_dtmf_key_txt); 100 101 static const char * const da7213_tonegen_swg_sel_txt[] = { 102 "Sum", "SWG1", "SWG2", "Sum" 103 }; 104 105 static const struct soc_enum da7213_tonegen_swg_sel = 106 SOC_ENUM_SINGLE(DA7213_TONE_GEN_CFG2, DA7213_SWG_SEL_SHIFT, 107 DA7213_SWG_SEL_MAX, da7213_tonegen_swg_sel_txt); 108 109 /* Gain ramping rate value */ 110 static const char * const da7213_gain_ramp_rate_txt[] = { 111 "nominal rate * 8", "nominal rate * 16", "nominal rate / 16", 112 "nominal rate / 32" 113 }; 114 115 static SOC_ENUM_SINGLE_DECL(da7213_gain_ramp_rate, 116 DA7213_GAIN_RAMP_CTRL, 117 DA7213_GAIN_RAMP_RATE_SHIFT, 118 da7213_gain_ramp_rate_txt); 119 120 /* DAC noise gate setup time value */ 121 static const char * const da7213_dac_ng_setup_time_txt[] = { 122 "256 samples", "512 samples", "1024 samples", "2048 samples" 123 }; 124 125 static SOC_ENUM_SINGLE_DECL(da7213_dac_ng_setup_time, 126 DA7213_DAC_NG_SETUP_TIME, 127 DA7213_DAC_NG_SETUP_TIME_SHIFT, 128 da7213_dac_ng_setup_time_txt); 129 130 /* DAC noise gate rampup rate value */ 131 static const char * const da7213_dac_ng_rampup_txt[] = { 132 "0.02 ms/dB", "0.16 ms/dB" 133 }; 134 135 static SOC_ENUM_SINGLE_DECL(da7213_dac_ng_rampup_rate, 136 DA7213_DAC_NG_SETUP_TIME, 137 DA7213_DAC_NG_RAMPUP_RATE_SHIFT, 138 da7213_dac_ng_rampup_txt); 139 140 /* DAC noise gate rampdown rate value */ 141 static const char * const da7213_dac_ng_rampdown_txt[] = { 142 "0.64 ms/dB", "20.48 ms/dB" 143 }; 144 145 static SOC_ENUM_SINGLE_DECL(da7213_dac_ng_rampdown_rate, 146 DA7213_DAC_NG_SETUP_TIME, 147 DA7213_DAC_NG_RAMPDN_RATE_SHIFT, 148 da7213_dac_ng_rampdown_txt); 149 150 /* DAC soft mute rate value */ 151 static const char * const da7213_dac_soft_mute_rate_txt[] = { 152 "1", "2", "4", "8", "16", "32", "64" 153 }; 154 155 static SOC_ENUM_SINGLE_DECL(da7213_dac_soft_mute_rate, 156 DA7213_DAC_FILTERS5, 157 DA7213_DAC_SOFTMUTE_RATE_SHIFT, 158 da7213_dac_soft_mute_rate_txt); 159 160 /* ALC Attack Rate select */ 161 static const char * const da7213_alc_attack_rate_txt[] = { 162 "44/fs", "88/fs", "176/fs", "352/fs", "704/fs", "1408/fs", "2816/fs", 163 "5632/fs", "11264/fs", "22528/fs", "45056/fs", "90112/fs", "180224/fs" 164 }; 165 166 static SOC_ENUM_SINGLE_DECL(da7213_alc_attack_rate, 167 DA7213_ALC_CTRL2, 168 DA7213_ALC_ATTACK_SHIFT, 169 da7213_alc_attack_rate_txt); 170 171 /* ALC Release Rate select */ 172 static const char * const da7213_alc_release_rate_txt[] = { 173 "176/fs", "352/fs", "704/fs", "1408/fs", "2816/fs", "5632/fs", 174 "11264/fs", "22528/fs", "45056/fs", "90112/fs", "180224/fs" 175 }; 176 177 static SOC_ENUM_SINGLE_DECL(da7213_alc_release_rate, 178 DA7213_ALC_CTRL2, 179 DA7213_ALC_RELEASE_SHIFT, 180 da7213_alc_release_rate_txt); 181 182 /* ALC Hold Time select */ 183 static const char * const da7213_alc_hold_time_txt[] = { 184 "62/fs", "124/fs", "248/fs", "496/fs", "992/fs", "1984/fs", "3968/fs", 185 "7936/fs", "15872/fs", "31744/fs", "63488/fs", "126976/fs", 186 "253952/fs", "507904/fs", "1015808/fs", "2031616/fs" 187 }; 188 189 static SOC_ENUM_SINGLE_DECL(da7213_alc_hold_time, 190 DA7213_ALC_CTRL3, 191 DA7213_ALC_HOLD_SHIFT, 192 da7213_alc_hold_time_txt); 193 194 /* ALC Input Signal Tracking rate select */ 195 static const char * const da7213_alc_integ_rate_txt[] = { 196 "1/4", "1/16", "1/256", "1/65536" 197 }; 198 199 static SOC_ENUM_SINGLE_DECL(da7213_alc_integ_attack_rate, 200 DA7213_ALC_CTRL3, 201 DA7213_ALC_INTEG_ATTACK_SHIFT, 202 da7213_alc_integ_rate_txt); 203 204 static SOC_ENUM_SINGLE_DECL(da7213_alc_integ_release_rate, 205 DA7213_ALC_CTRL3, 206 DA7213_ALC_INTEG_RELEASE_SHIFT, 207 da7213_alc_integ_rate_txt); 208 209 210 /* 211 * Control Functions 212 */ 213 214 /* Locked Kcontrol calls */ 215 static int da7213_volsw_locked_get(struct snd_kcontrol *kcontrol, 216 struct snd_ctl_elem_value *ucontrol) 217 { 218 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 219 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 220 221 guard(mutex)(&da7213->ctrl_lock); 222 223 return snd_soc_get_volsw(kcontrol, ucontrol); 224 } 225 226 static int da7213_volsw_locked_put(struct snd_kcontrol *kcontrol, 227 struct snd_ctl_elem_value *ucontrol) 228 { 229 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 230 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 231 232 guard(mutex)(&da7213->ctrl_lock); 233 234 return snd_soc_put_volsw(kcontrol, ucontrol); 235 } 236 237 static int da7213_enum_locked_get(struct snd_kcontrol *kcontrol, 238 struct snd_ctl_elem_value *ucontrol) 239 { 240 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 241 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 242 243 guard(mutex)(&da7213->ctrl_lock); 244 245 return snd_soc_get_enum_double(kcontrol, ucontrol); 246 } 247 248 static int da7213_enum_locked_put(struct snd_kcontrol *kcontrol, 249 struct snd_ctl_elem_value *ucontrol) 250 { 251 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 252 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 253 254 guard(mutex)(&da7213->ctrl_lock); 255 256 return snd_soc_put_enum_double(kcontrol, ucontrol); 257 } 258 259 /* ALC */ 260 static int da7213_get_alc_data(struct snd_soc_component *component, u8 reg_val) 261 { 262 int mid_data, top_data; 263 int sum = 0; 264 u8 iteration; 265 266 for (iteration = 0; iteration < DA7213_ALC_AVG_ITERATIONS; 267 iteration++) { 268 /* Select the left or right channel and capture data */ 269 snd_soc_component_write(component, DA7213_ALC_CIC_OP_LVL_CTRL, reg_val); 270 271 /* Select middle 8 bits for read back from data register */ 272 snd_soc_component_write(component, DA7213_ALC_CIC_OP_LVL_CTRL, 273 reg_val | DA7213_ALC_DATA_MIDDLE); 274 mid_data = snd_soc_component_read(component, DA7213_ALC_CIC_OP_LVL_DATA); 275 276 /* Select top 8 bits for read back from data register */ 277 snd_soc_component_write(component, DA7213_ALC_CIC_OP_LVL_CTRL, 278 reg_val | DA7213_ALC_DATA_TOP); 279 top_data = snd_soc_component_read(component, DA7213_ALC_CIC_OP_LVL_DATA); 280 281 sum += ((mid_data << 8) | (top_data << 16)); 282 } 283 284 return sum / DA7213_ALC_AVG_ITERATIONS; 285 } 286 287 static void da7213_alc_calib_man(struct snd_soc_component *component) 288 { 289 u8 reg_val; 290 int avg_left_data, avg_right_data, offset_l, offset_r; 291 292 /* Calculate average for Left and Right data */ 293 /* Left Data */ 294 avg_left_data = da7213_get_alc_data(component, 295 DA7213_ALC_CIC_OP_CHANNEL_LEFT); 296 /* Right Data */ 297 avg_right_data = da7213_get_alc_data(component, 298 DA7213_ALC_CIC_OP_CHANNEL_RIGHT); 299 300 /* Calculate DC offset */ 301 offset_l = -avg_left_data; 302 offset_r = -avg_right_data; 303 304 reg_val = (offset_l & DA7213_ALC_OFFSET_15_8) >> 8; 305 snd_soc_component_write(component, DA7213_ALC_OFFSET_MAN_M_L, reg_val); 306 reg_val = (offset_l & DA7213_ALC_OFFSET_19_16) >> 16; 307 snd_soc_component_write(component, DA7213_ALC_OFFSET_MAN_U_L, reg_val); 308 309 reg_val = (offset_r & DA7213_ALC_OFFSET_15_8) >> 8; 310 snd_soc_component_write(component, DA7213_ALC_OFFSET_MAN_M_R, reg_val); 311 reg_val = (offset_r & DA7213_ALC_OFFSET_19_16) >> 16; 312 snd_soc_component_write(component, DA7213_ALC_OFFSET_MAN_U_R, reg_val); 313 314 /* Enable analog/digital gain mode & offset cancellation */ 315 snd_soc_component_update_bits(component, DA7213_ALC_CTRL1, 316 DA7213_ALC_OFFSET_EN | DA7213_ALC_SYNC_MODE, 317 DA7213_ALC_OFFSET_EN | DA7213_ALC_SYNC_MODE); 318 } 319 320 static void da7213_alc_calib_auto(struct snd_soc_component *component) 321 { 322 u8 alc_ctrl1; 323 324 /* Begin auto calibration and wait for completion */ 325 snd_soc_component_update_bits(component, DA7213_ALC_CTRL1, DA7213_ALC_AUTO_CALIB_EN, 326 DA7213_ALC_AUTO_CALIB_EN); 327 do { 328 alc_ctrl1 = snd_soc_component_read(component, DA7213_ALC_CTRL1); 329 } while (alc_ctrl1 & DA7213_ALC_AUTO_CALIB_EN); 330 331 /* If auto calibration fails, fall back to digital gain only mode */ 332 if (alc_ctrl1 & DA7213_ALC_CALIB_OVERFLOW) { 333 dev_warn(component->dev, 334 "ALC auto calibration failed with overflow\n"); 335 snd_soc_component_update_bits(component, DA7213_ALC_CTRL1, 336 DA7213_ALC_OFFSET_EN | DA7213_ALC_SYNC_MODE, 337 0); 338 } else { 339 /* Enable analog/digital gain mode & offset cancellation */ 340 snd_soc_component_update_bits(component, DA7213_ALC_CTRL1, 341 DA7213_ALC_OFFSET_EN | DA7213_ALC_SYNC_MODE, 342 DA7213_ALC_OFFSET_EN | DA7213_ALC_SYNC_MODE); 343 } 344 345 } 346 347 static void da7213_alc_calib(struct snd_soc_component *component) 348 { 349 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 350 u8 adc_l_ctrl, adc_r_ctrl; 351 u8 mixin_l_sel, mixin_r_sel; 352 u8 mic_1_ctrl, mic_2_ctrl; 353 354 /* Save current values from ADC control registers */ 355 adc_l_ctrl = snd_soc_component_read(component, DA7213_ADC_L_CTRL); 356 adc_r_ctrl = snd_soc_component_read(component, DA7213_ADC_R_CTRL); 357 358 /* Save current values from MIXIN_L/R_SELECT registers */ 359 mixin_l_sel = snd_soc_component_read(component, DA7213_MIXIN_L_SELECT); 360 mixin_r_sel = snd_soc_component_read(component, DA7213_MIXIN_R_SELECT); 361 362 /* Save current values from MIC control registers */ 363 mic_1_ctrl = snd_soc_component_read(component, DA7213_MIC_1_CTRL); 364 mic_2_ctrl = snd_soc_component_read(component, DA7213_MIC_2_CTRL); 365 366 /* Enable ADC Left and Right */ 367 snd_soc_component_update_bits(component, DA7213_ADC_L_CTRL, DA7213_ADC_EN, 368 DA7213_ADC_EN); 369 snd_soc_component_update_bits(component, DA7213_ADC_R_CTRL, DA7213_ADC_EN, 370 DA7213_ADC_EN); 371 372 /* Enable MIC paths */ 373 snd_soc_component_update_bits(component, DA7213_MIXIN_L_SELECT, 374 DA7213_MIXIN_L_MIX_SELECT_MIC_1 | 375 DA7213_MIXIN_L_MIX_SELECT_MIC_2, 376 DA7213_MIXIN_L_MIX_SELECT_MIC_1 | 377 DA7213_MIXIN_L_MIX_SELECT_MIC_2); 378 snd_soc_component_update_bits(component, DA7213_MIXIN_R_SELECT, 379 DA7213_MIXIN_R_MIX_SELECT_MIC_2 | 380 DA7213_MIXIN_R_MIX_SELECT_MIC_1, 381 DA7213_MIXIN_R_MIX_SELECT_MIC_2 | 382 DA7213_MIXIN_R_MIX_SELECT_MIC_1); 383 384 /* Mute MIC PGAs */ 385 snd_soc_component_update_bits(component, DA7213_MIC_1_CTRL, DA7213_MUTE_EN, 386 DA7213_MUTE_EN); 387 snd_soc_component_update_bits(component, DA7213_MIC_2_CTRL, DA7213_MUTE_EN, 388 DA7213_MUTE_EN); 389 390 /* Perform calibration */ 391 if (da7213->alc_calib_auto) 392 da7213_alc_calib_auto(component); 393 else 394 da7213_alc_calib_man(component); 395 396 /* Restore MIXIN_L/R_SELECT registers to their original states */ 397 snd_soc_component_write(component, DA7213_MIXIN_L_SELECT, mixin_l_sel); 398 snd_soc_component_write(component, DA7213_MIXIN_R_SELECT, mixin_r_sel); 399 400 /* Restore ADC control registers to their original states */ 401 snd_soc_component_write(component, DA7213_ADC_L_CTRL, adc_l_ctrl); 402 snd_soc_component_write(component, DA7213_ADC_R_CTRL, adc_r_ctrl); 403 404 /* Restore original values of MIC control registers */ 405 snd_soc_component_write(component, DA7213_MIC_1_CTRL, mic_1_ctrl); 406 snd_soc_component_write(component, DA7213_MIC_2_CTRL, mic_2_ctrl); 407 } 408 409 static int da7213_put_mixin_gain(struct snd_kcontrol *kcontrol, 410 struct snd_ctl_elem_value *ucontrol) 411 { 412 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 413 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 414 int ret; 415 416 ret = snd_soc_put_volsw_2r(kcontrol, ucontrol); 417 418 /* If ALC in operation, make sure calibrated offsets are updated */ 419 if ((!ret) && (da7213->alc_en)) 420 da7213_alc_calib(component); 421 422 return ret; 423 } 424 425 static int da7213_put_alc_sw(struct snd_kcontrol *kcontrol, 426 struct snd_ctl_elem_value *ucontrol) 427 { 428 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 429 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 430 431 /* Force ALC offset calibration if enabling ALC */ 432 if (ucontrol->value.integer.value[0] || 433 ucontrol->value.integer.value[1]) { 434 if (!da7213->alc_en) { 435 da7213_alc_calib(component); 436 da7213->alc_en = true; 437 } 438 } else { 439 da7213->alc_en = false; 440 } 441 442 return snd_soc_put_volsw(kcontrol, ucontrol); 443 } 444 445 /* ToneGen */ 446 static int da7213_tonegen_freq_get(struct snd_kcontrol *kcontrol, 447 struct snd_ctl_elem_value *ucontrol) 448 { 449 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 450 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 451 struct soc_mixer_control *mixer_ctrl = 452 (struct soc_mixer_control *) kcontrol->private_value; 453 unsigned int reg = mixer_ctrl->reg; 454 __le16 val; 455 int ret; 456 457 scoped_guard(mutex, &da7213->ctrl_lock) 458 ret = regmap_raw_read(da7213->regmap, reg, &val, sizeof(val)); 459 460 if (ret) 461 return ret; 462 463 /* 464 * Frequency value spans two 8-bit registers, lower then upper byte. 465 * Therefore we need to convert to host endianness here. 466 */ 467 ucontrol->value.integer.value[0] = le16_to_cpu(val); 468 469 return 0; 470 } 471 472 static int da7213_tonegen_freq_put(struct snd_kcontrol *kcontrol, 473 struct snd_ctl_elem_value *ucontrol) 474 { 475 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 476 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 477 struct soc_mixer_control *mixer_ctrl = 478 (struct soc_mixer_control *) kcontrol->private_value; 479 unsigned int reg = mixer_ctrl->reg; 480 __le16 val_new, val_old; 481 int ret; 482 483 /* 484 * Frequency value spans two 8-bit registers, lower then upper byte. 485 * Therefore we need to convert to little endian here to align with 486 * HW registers. 487 */ 488 val_new = cpu_to_le16(ucontrol->value.integer.value[0]); 489 490 guard(mutex)(&da7213->ctrl_lock); 491 ret = regmap_raw_read(da7213->regmap, reg, &val_old, sizeof(val_old)); 492 if (ret == 0 && (val_old != val_new)) 493 ret = regmap_raw_write(da7213->regmap, reg, 494 &val_new, sizeof(val_new)); 495 496 if (ret < 0) 497 return ret; 498 499 return val_old != val_new; 500 } 501 502 /* 503 * KControls 504 */ 505 506 static const struct snd_kcontrol_new da7213_snd_controls[] = { 507 508 /* Volume controls */ 509 SOC_SINGLE_TLV("Mic 1 Volume", DA7213_MIC_1_GAIN, 510 DA7213_MIC_AMP_GAIN_SHIFT, DA7213_MIC_AMP_GAIN_MAX, 511 DA7213_NO_INVERT, mic_vol_tlv), 512 SOC_SINGLE_TLV("Mic 2 Volume", DA7213_MIC_2_GAIN, 513 DA7213_MIC_AMP_GAIN_SHIFT, DA7213_MIC_AMP_GAIN_MAX, 514 DA7213_NO_INVERT, mic_vol_tlv), 515 SOC_DOUBLE_R_TLV("Aux Volume", DA7213_AUX_L_GAIN, DA7213_AUX_R_GAIN, 516 DA7213_AUX_AMP_GAIN_SHIFT, DA7213_AUX_AMP_GAIN_MAX, 517 DA7213_NO_INVERT, aux_vol_tlv), 518 SOC_DOUBLE_R_EXT_TLV("Mixin PGA Volume", DA7213_MIXIN_L_GAIN, 519 DA7213_MIXIN_R_GAIN, DA7213_MIXIN_AMP_GAIN_SHIFT, 520 DA7213_MIXIN_AMP_GAIN_MAX, DA7213_NO_INVERT, 521 snd_soc_get_volsw_2r, da7213_put_mixin_gain, 522 mixin_gain_tlv), 523 SOC_DOUBLE_R_TLV("ADC Volume", DA7213_ADC_L_GAIN, DA7213_ADC_R_GAIN, 524 DA7213_ADC_AMP_GAIN_SHIFT, DA7213_ADC_AMP_GAIN_MAX, 525 DA7213_NO_INVERT, digital_gain_tlv), 526 SOC_DOUBLE_R_TLV("DAC Volume", DA7213_DAC_L_GAIN, DA7213_DAC_R_GAIN, 527 DA7213_DAC_AMP_GAIN_SHIFT, DA7213_DAC_AMP_GAIN_MAX, 528 DA7213_NO_INVERT, digital_gain_tlv), 529 SOC_DOUBLE_R_TLV("Headphone Volume", DA7213_HP_L_GAIN, DA7213_HP_R_GAIN, 530 DA7213_HP_AMP_GAIN_SHIFT, DA7213_HP_AMP_GAIN_MAX, 531 DA7213_NO_INVERT, hp_vol_tlv), 532 SOC_SINGLE_TLV("Lineout Volume", DA7213_LINE_GAIN, 533 DA7213_LINE_AMP_GAIN_SHIFT, DA7213_LINE_AMP_GAIN_MAX, 534 DA7213_NO_INVERT, lineout_vol_tlv), 535 536 /* DAC Equalizer controls */ 537 SOC_SINGLE("DAC EQ Switch", DA7213_DAC_FILTERS4, DA7213_DAC_EQ_EN_SHIFT, 538 DA7213_DAC_EQ_EN_MAX, DA7213_NO_INVERT), 539 SOC_SINGLE_TLV("DAC EQ1 Volume", DA7213_DAC_FILTERS2, 540 DA7213_DAC_EQ_BAND1_SHIFT, DA7213_DAC_EQ_BAND_MAX, 541 DA7213_NO_INVERT, eq_gain_tlv), 542 SOC_SINGLE_TLV("DAC EQ2 Volume", DA7213_DAC_FILTERS2, 543 DA7213_DAC_EQ_BAND2_SHIFT, DA7213_DAC_EQ_BAND_MAX, 544 DA7213_NO_INVERT, eq_gain_tlv), 545 SOC_SINGLE_TLV("DAC EQ3 Volume", DA7213_DAC_FILTERS3, 546 DA7213_DAC_EQ_BAND3_SHIFT, DA7213_DAC_EQ_BAND_MAX, 547 DA7213_NO_INVERT, eq_gain_tlv), 548 SOC_SINGLE_TLV("DAC EQ4 Volume", DA7213_DAC_FILTERS3, 549 DA7213_DAC_EQ_BAND4_SHIFT, DA7213_DAC_EQ_BAND_MAX, 550 DA7213_NO_INVERT, eq_gain_tlv), 551 SOC_SINGLE_TLV("DAC EQ5 Volume", DA7213_DAC_FILTERS4, 552 DA7213_DAC_EQ_BAND5_SHIFT, DA7213_DAC_EQ_BAND_MAX, 553 DA7213_NO_INVERT, eq_gain_tlv), 554 555 /* High Pass Filter and Voice Mode controls */ 556 SOC_SINGLE("ADC HPF Switch", DA7213_ADC_FILTERS1, DA7213_HPF_EN_SHIFT, 557 DA7213_HPF_EN_MAX, DA7213_NO_INVERT), 558 SOC_ENUM("ADC HPF Cutoff", da7213_adc_audio_hpf_corner), 559 SOC_SINGLE("ADC Voice Mode Switch", DA7213_ADC_FILTERS1, 560 DA7213_VOICE_EN_SHIFT, DA7213_VOICE_EN_MAX, 561 DA7213_NO_INVERT), 562 SOC_ENUM("ADC Voice Cutoff", da7213_adc_voice_hpf_corner), 563 564 SOC_SINGLE("DAC HPF Switch", DA7213_DAC_FILTERS1, DA7213_HPF_EN_SHIFT, 565 DA7213_HPF_EN_MAX, DA7213_NO_INVERT), 566 SOC_ENUM("DAC HPF Cutoff", da7213_dac_audio_hpf_corner), 567 SOC_SINGLE("DAC Voice Mode Switch", DA7213_DAC_FILTERS1, 568 DA7213_VOICE_EN_SHIFT, DA7213_VOICE_EN_MAX, 569 DA7213_NO_INVERT), 570 SOC_ENUM("DAC Voice Cutoff", da7213_dac_voice_hpf_corner), 571 572 /* Mute controls */ 573 SOC_SINGLE("Mic 1 Switch", DA7213_MIC_1_CTRL, DA7213_MUTE_EN_SHIFT, 574 DA7213_MUTE_EN_MAX, DA7213_INVERT), 575 SOC_SINGLE("Mic 2 Switch", DA7213_MIC_2_CTRL, DA7213_MUTE_EN_SHIFT, 576 DA7213_MUTE_EN_MAX, DA7213_INVERT), 577 SOC_DOUBLE_R("Aux Switch", DA7213_AUX_L_CTRL, DA7213_AUX_R_CTRL, 578 DA7213_MUTE_EN_SHIFT, DA7213_MUTE_EN_MAX, DA7213_INVERT), 579 SOC_DOUBLE_R("Mixin PGA Switch", DA7213_MIXIN_L_CTRL, 580 DA7213_MIXIN_R_CTRL, DA7213_MUTE_EN_SHIFT, 581 DA7213_MUTE_EN_MAX, DA7213_INVERT), 582 SOC_DOUBLE_R("ADC Switch", DA7213_ADC_L_CTRL, DA7213_ADC_R_CTRL, 583 DA7213_MUTE_EN_SHIFT, DA7213_MUTE_EN_MAX, DA7213_INVERT), 584 SOC_DOUBLE_R("Headphone Switch", DA7213_HP_L_CTRL, DA7213_HP_R_CTRL, 585 DA7213_MUTE_EN_SHIFT, DA7213_MUTE_EN_MAX, DA7213_INVERT), 586 SOC_SINGLE("Lineout Switch", DA7213_LINE_CTRL, DA7213_MUTE_EN_SHIFT, 587 DA7213_MUTE_EN_MAX, DA7213_INVERT), 588 SOC_SINGLE("DAC Soft Mute Switch", DA7213_DAC_FILTERS5, 589 DA7213_DAC_SOFTMUTE_EN_SHIFT, DA7213_DAC_SOFTMUTE_EN_MAX, 590 DA7213_NO_INVERT), 591 SOC_ENUM("DAC Soft Mute Rate", da7213_dac_soft_mute_rate), 592 593 /* Zero Cross controls */ 594 SOC_DOUBLE_R("Aux ZC Switch", DA7213_AUX_L_CTRL, DA7213_AUX_R_CTRL, 595 DA7213_ZC_EN_SHIFT, DA7213_ZC_EN_MAX, DA7213_NO_INVERT), 596 SOC_DOUBLE_R("Mixin PGA ZC Switch", DA7213_MIXIN_L_CTRL, 597 DA7213_MIXIN_R_CTRL, DA7213_ZC_EN_SHIFT, DA7213_ZC_EN_MAX, 598 DA7213_NO_INVERT), 599 SOC_DOUBLE_R("Headphone ZC Switch", DA7213_HP_L_CTRL, DA7213_HP_R_CTRL, 600 DA7213_ZC_EN_SHIFT, DA7213_ZC_EN_MAX, DA7213_NO_INVERT), 601 602 /* Tone Generator */ 603 SOC_SINGLE_EXT_TLV("ToneGen Volume", DA7213_TONE_GEN_CFG2, 604 DA7213_TONE_GEN_GAIN_SHIFT, DA7213_TONE_GEN_GAIN_MAX, 605 DA7213_NO_INVERT, da7213_volsw_locked_get, 606 da7213_volsw_locked_put, da7213_tonegen_gain_tlv), 607 SOC_ENUM_EXT("ToneGen DTMF Key", da7213_tonegen_dtmf_key, 608 da7213_enum_locked_get, da7213_enum_locked_put), 609 SOC_SINGLE_EXT("ToneGen DTMF Switch", DA7213_TONE_GEN_CFG1, 610 DA7213_DTMF_EN_SHIFT, DA7213_SWITCH_EN_MAX, 611 DA7213_NO_INVERT, da7213_volsw_locked_get, 612 da7213_volsw_locked_put), 613 SOC_SINGLE_EXT("ToneGen Start", DA7213_TONE_GEN_CFG1, 614 DA7213_START_STOPN_SHIFT, DA7213_SWITCH_EN_MAX, 615 DA7213_NO_INVERT, da7213_volsw_locked_get, 616 da7213_volsw_locked_put), 617 SOC_ENUM_EXT("ToneGen Sinewave Gen Type", da7213_tonegen_swg_sel, 618 da7213_enum_locked_get, da7213_enum_locked_put), 619 SOC_SINGLE_EXT("ToneGen Sinewave1 Freq", DA7213_TONE_GEN_FREQ1_L, 620 DA7213_FREQ1_L_SHIFT, DA7213_FREQ_MAX, DA7213_NO_INVERT, 621 da7213_tonegen_freq_get, da7213_tonegen_freq_put), 622 SOC_SINGLE_EXT("ToneGen Sinewave2 Freq", DA7213_TONE_GEN_FREQ2_L, 623 DA7213_FREQ2_L_SHIFT, DA7213_FREQ_MAX, DA7213_NO_INVERT, 624 da7213_tonegen_freq_get, da7213_tonegen_freq_put), 625 SOC_SINGLE_EXT("ToneGen On Time", DA7213_TONE_GEN_ON_PER, 626 DA7213_BEEP_ON_PER_SHIFT, DA7213_BEEP_ON_OFF_MAX, 627 DA7213_NO_INVERT, da7213_volsw_locked_get, 628 da7213_volsw_locked_put), 629 SOC_SINGLE("ToneGen Off Time", DA7213_TONE_GEN_OFF_PER, 630 DA7213_BEEP_OFF_PER_SHIFT, DA7213_BEEP_ON_OFF_MAX, 631 DA7213_NO_INVERT), 632 633 /* Gain Ramping controls */ 634 SOC_DOUBLE_R("Aux Gain Ramping Switch", DA7213_AUX_L_CTRL, 635 DA7213_AUX_R_CTRL, DA7213_GAIN_RAMP_EN_SHIFT, 636 DA7213_GAIN_RAMP_EN_MAX, DA7213_NO_INVERT), 637 SOC_DOUBLE_R("Mixin Gain Ramping Switch", DA7213_MIXIN_L_CTRL, 638 DA7213_MIXIN_R_CTRL, DA7213_GAIN_RAMP_EN_SHIFT, 639 DA7213_GAIN_RAMP_EN_MAX, DA7213_NO_INVERT), 640 SOC_DOUBLE_R("ADC Gain Ramping Switch", DA7213_ADC_L_CTRL, 641 DA7213_ADC_R_CTRL, DA7213_GAIN_RAMP_EN_SHIFT, 642 DA7213_GAIN_RAMP_EN_MAX, DA7213_NO_INVERT), 643 SOC_DOUBLE_R("DAC Gain Ramping Switch", DA7213_DAC_L_CTRL, 644 DA7213_DAC_R_CTRL, DA7213_GAIN_RAMP_EN_SHIFT, 645 DA7213_GAIN_RAMP_EN_MAX, DA7213_NO_INVERT), 646 SOC_DOUBLE_R("Headphone Gain Ramping Switch", DA7213_HP_L_CTRL, 647 DA7213_HP_R_CTRL, DA7213_GAIN_RAMP_EN_SHIFT, 648 DA7213_GAIN_RAMP_EN_MAX, DA7213_NO_INVERT), 649 SOC_SINGLE("Lineout Gain Ramping Switch", DA7213_LINE_CTRL, 650 DA7213_GAIN_RAMP_EN_SHIFT, DA7213_GAIN_RAMP_EN_MAX, 651 DA7213_NO_INVERT), 652 SOC_ENUM("Gain Ramping Rate", da7213_gain_ramp_rate), 653 654 /* DAC Noise Gate controls */ 655 SOC_SINGLE("DAC NG Switch", DA7213_DAC_NG_CTRL, DA7213_DAC_NG_EN_SHIFT, 656 DA7213_DAC_NG_EN_MAX, DA7213_NO_INVERT), 657 SOC_ENUM("DAC NG Setup Time", da7213_dac_ng_setup_time), 658 SOC_ENUM("DAC NG Rampup Rate", da7213_dac_ng_rampup_rate), 659 SOC_ENUM("DAC NG Rampdown Rate", da7213_dac_ng_rampdown_rate), 660 SOC_SINGLE("DAC NG OFF Threshold", DA7213_DAC_NG_OFF_THRESHOLD, 661 DA7213_DAC_NG_THRESHOLD_SHIFT, DA7213_DAC_NG_THRESHOLD_MAX, 662 DA7213_NO_INVERT), 663 SOC_SINGLE("DAC NG ON Threshold", DA7213_DAC_NG_ON_THRESHOLD, 664 DA7213_DAC_NG_THRESHOLD_SHIFT, DA7213_DAC_NG_THRESHOLD_MAX, 665 DA7213_NO_INVERT), 666 667 /* DAC Routing & Inversion */ 668 SOC_DOUBLE("DAC Mono Switch", DA7213_DIG_ROUTING_DAC, 669 DA7213_DAC_L_MONO_SHIFT, DA7213_DAC_R_MONO_SHIFT, 670 DA7213_DAC_MONO_MAX, DA7213_NO_INVERT), 671 SOC_DOUBLE("DAC Invert Switch", DA7213_DIG_CTRL, DA7213_DAC_L_INV_SHIFT, 672 DA7213_DAC_R_INV_SHIFT, DA7213_DAC_INV_MAX, 673 DA7213_NO_INVERT), 674 675 /* DMIC controls */ 676 SOC_DOUBLE_R("DMIC Switch", DA7213_MIXIN_L_SELECT, 677 DA7213_MIXIN_R_SELECT, DA7213_DMIC_EN_SHIFT, 678 DA7213_DMIC_EN_MAX, DA7213_NO_INVERT), 679 680 /* ALC Controls */ 681 SOC_DOUBLE_EXT("ALC Switch", DA7213_ALC_CTRL1, DA7213_ALC_L_EN_SHIFT, 682 DA7213_ALC_R_EN_SHIFT, DA7213_ALC_EN_MAX, 683 DA7213_NO_INVERT, snd_soc_get_volsw, da7213_put_alc_sw), 684 SOC_ENUM("ALC Attack Rate", da7213_alc_attack_rate), 685 SOC_ENUM("ALC Release Rate", da7213_alc_release_rate), 686 SOC_ENUM("ALC Hold Time", da7213_alc_hold_time), 687 /* 688 * Rate at which input signal envelope is tracked as the signal gets 689 * larger 690 */ 691 SOC_ENUM("ALC Integ Attack Rate", da7213_alc_integ_attack_rate), 692 /* 693 * Rate at which input signal envelope is tracked as the signal gets 694 * smaller 695 */ 696 SOC_ENUM("ALC Integ Release Rate", da7213_alc_integ_release_rate), 697 SOC_SINGLE_TLV("ALC Noise Threshold Volume", DA7213_ALC_NOISE, 698 DA7213_ALC_THRESHOLD_SHIFT, DA7213_ALC_THRESHOLD_MAX, 699 DA7213_INVERT, alc_threshold_tlv), 700 SOC_SINGLE_TLV("ALC Min Threshold Volume", DA7213_ALC_TARGET_MIN, 701 DA7213_ALC_THRESHOLD_SHIFT, DA7213_ALC_THRESHOLD_MAX, 702 DA7213_INVERT, alc_threshold_tlv), 703 SOC_SINGLE_TLV("ALC Max Threshold Volume", DA7213_ALC_TARGET_MAX, 704 DA7213_ALC_THRESHOLD_SHIFT, DA7213_ALC_THRESHOLD_MAX, 705 DA7213_INVERT, alc_threshold_tlv), 706 SOC_SINGLE_TLV("ALC Max Attenuation Volume", DA7213_ALC_GAIN_LIMITS, 707 DA7213_ALC_ATTEN_MAX_SHIFT, 708 DA7213_ALC_ATTEN_GAIN_MAX_MAX, DA7213_NO_INVERT, 709 alc_gain_tlv), 710 SOC_SINGLE_TLV("ALC Max Gain Volume", DA7213_ALC_GAIN_LIMITS, 711 DA7213_ALC_GAIN_MAX_SHIFT, DA7213_ALC_ATTEN_GAIN_MAX_MAX, 712 DA7213_NO_INVERT, alc_gain_tlv), 713 SOC_SINGLE_TLV("ALC Min Analog Gain Volume", DA7213_ALC_ANA_GAIN_LIMITS, 714 DA7213_ALC_ANA_GAIN_MIN_SHIFT, DA7213_ALC_ANA_GAIN_MAX, 715 DA7213_NO_INVERT, alc_analog_gain_tlv), 716 SOC_SINGLE_TLV("ALC Max Analog Gain Volume", DA7213_ALC_ANA_GAIN_LIMITS, 717 DA7213_ALC_ANA_GAIN_MAX_SHIFT, DA7213_ALC_ANA_GAIN_MAX, 718 DA7213_NO_INVERT, alc_analog_gain_tlv), 719 SOC_SINGLE("ALC Anticlip Mode Switch", DA7213_ALC_ANTICLIP_CTRL, 720 DA7213_ALC_ANTICLIP_EN_SHIFT, DA7213_ALC_ANTICLIP_EN_MAX, 721 DA7213_NO_INVERT), 722 SOC_SINGLE("ALC Anticlip Level", DA7213_ALC_ANTICLIP_LEVEL, 723 DA7213_ALC_ANTICLIP_LEVEL_SHIFT, 724 DA7213_ALC_ANTICLIP_LEVEL_MAX, DA7213_NO_INVERT), 725 }; 726 727 728 /* 729 * DAPM 730 */ 731 732 /* 733 * Enums 734 */ 735 736 /* MIC PGA source select */ 737 static const char * const da7213_mic_amp_in_sel_txt[] = { 738 "Differential", "MIC_P", "MIC_N" 739 }; 740 741 static SOC_ENUM_SINGLE_DECL(da7213_mic_1_amp_in_sel, 742 DA7213_MIC_1_CTRL, 743 DA7213_MIC_AMP_IN_SEL_SHIFT, 744 da7213_mic_amp_in_sel_txt); 745 static const struct snd_kcontrol_new da7213_mic_1_amp_in_sel_mux = 746 SOC_DAPM_ENUM("Mic 1 Amp Source MUX", da7213_mic_1_amp_in_sel); 747 748 static SOC_ENUM_SINGLE_DECL(da7213_mic_2_amp_in_sel, 749 DA7213_MIC_2_CTRL, 750 DA7213_MIC_AMP_IN_SEL_SHIFT, 751 da7213_mic_amp_in_sel_txt); 752 static const struct snd_kcontrol_new da7213_mic_2_amp_in_sel_mux = 753 SOC_DAPM_ENUM("Mic 2 Amp Source MUX", da7213_mic_2_amp_in_sel); 754 755 /* DAI routing select */ 756 static const char * const da7213_dai_src_txt[] = { 757 "ADC Left", "ADC Right", "DAI Input Left", "DAI Input Right" 758 }; 759 760 static SOC_ENUM_SINGLE_DECL(da7213_dai_l_src, 761 DA7213_DIG_ROUTING_DAI, 762 DA7213_DAI_L_SRC_SHIFT, 763 da7213_dai_src_txt); 764 static const struct snd_kcontrol_new da7213_dai_l_src_mux = 765 SOC_DAPM_ENUM("DAI Left Source MUX", da7213_dai_l_src); 766 767 static SOC_ENUM_SINGLE_DECL(da7213_dai_r_src, 768 DA7213_DIG_ROUTING_DAI, 769 DA7213_DAI_R_SRC_SHIFT, 770 da7213_dai_src_txt); 771 static const struct snd_kcontrol_new da7213_dai_r_src_mux = 772 SOC_DAPM_ENUM("DAI Right Source MUX", da7213_dai_r_src); 773 774 /* DAC routing select */ 775 static const char * const da7213_dac_src_txt[] = { 776 "ADC Output Left", "ADC Output Right", "DAI Input Left", 777 "DAI Input Right" 778 }; 779 780 static SOC_ENUM_SINGLE_DECL(da7213_dac_l_src, 781 DA7213_DIG_ROUTING_DAC, 782 DA7213_DAC_L_SRC_SHIFT, 783 da7213_dac_src_txt); 784 static const struct snd_kcontrol_new da7213_dac_l_src_mux = 785 SOC_DAPM_ENUM("DAC Left Source MUX", da7213_dac_l_src); 786 787 static SOC_ENUM_SINGLE_DECL(da7213_dac_r_src, 788 DA7213_DIG_ROUTING_DAC, 789 DA7213_DAC_R_SRC_SHIFT, 790 da7213_dac_src_txt); 791 static const struct snd_kcontrol_new da7213_dac_r_src_mux = 792 SOC_DAPM_ENUM("DAC Right Source MUX", da7213_dac_r_src); 793 794 /* 795 * Mixer Controls 796 */ 797 798 /* Mixin Left */ 799 static const struct snd_kcontrol_new da7213_dapm_mixinl_controls[] = { 800 SOC_DAPM_SINGLE("Aux Left Switch", DA7213_MIXIN_L_SELECT, 801 DA7213_MIXIN_L_MIX_SELECT_AUX_L_SHIFT, 802 DA7213_MIXIN_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 803 SOC_DAPM_SINGLE("Mic 1 Switch", DA7213_MIXIN_L_SELECT, 804 DA7213_MIXIN_L_MIX_SELECT_MIC_1_SHIFT, 805 DA7213_MIXIN_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 806 SOC_DAPM_SINGLE("Mic 2 Switch", DA7213_MIXIN_L_SELECT, 807 DA7213_MIXIN_L_MIX_SELECT_MIC_2_SHIFT, 808 DA7213_MIXIN_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 809 SOC_DAPM_SINGLE("Mixin Right Switch", DA7213_MIXIN_L_SELECT, 810 DA7213_MIXIN_L_MIX_SELECT_MIXIN_R_SHIFT, 811 DA7213_MIXIN_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 812 }; 813 814 /* Mixin Right */ 815 static const struct snd_kcontrol_new da7213_dapm_mixinr_controls[] = { 816 SOC_DAPM_SINGLE("Aux Right Switch", DA7213_MIXIN_R_SELECT, 817 DA7213_MIXIN_R_MIX_SELECT_AUX_R_SHIFT, 818 DA7213_MIXIN_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 819 SOC_DAPM_SINGLE("Mic 2 Switch", DA7213_MIXIN_R_SELECT, 820 DA7213_MIXIN_R_MIX_SELECT_MIC_2_SHIFT, 821 DA7213_MIXIN_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 822 SOC_DAPM_SINGLE("Mic 1 Switch", DA7213_MIXIN_R_SELECT, 823 DA7213_MIXIN_R_MIX_SELECT_MIC_1_SHIFT, 824 DA7213_MIXIN_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 825 SOC_DAPM_SINGLE("Mixin Left Switch", DA7213_MIXIN_R_SELECT, 826 DA7213_MIXIN_R_MIX_SELECT_MIXIN_L_SHIFT, 827 DA7213_MIXIN_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 828 }; 829 830 /* Mixout Left */ 831 static const struct snd_kcontrol_new da7213_dapm_mixoutl_controls[] = { 832 SOC_DAPM_SINGLE("Aux Left Switch", DA7213_MIXOUT_L_SELECT, 833 DA7213_MIXOUT_L_MIX_SELECT_AUX_L_SHIFT, 834 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 835 SOC_DAPM_SINGLE("Mixin Left Switch", DA7213_MIXOUT_L_SELECT, 836 DA7213_MIXOUT_L_MIX_SELECT_MIXIN_L_SHIFT, 837 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 838 SOC_DAPM_SINGLE("Mixin Right Switch", DA7213_MIXOUT_L_SELECT, 839 DA7213_MIXOUT_L_MIX_SELECT_MIXIN_R_SHIFT, 840 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 841 SOC_DAPM_SINGLE("DAC Left Switch", DA7213_MIXOUT_L_SELECT, 842 DA7213_MIXOUT_L_MIX_SELECT_DAC_L_SHIFT, 843 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 844 SOC_DAPM_SINGLE("Aux Left Invert Switch", DA7213_MIXOUT_L_SELECT, 845 DA7213_MIXOUT_L_MIX_SELECT_AUX_L_INVERTED_SHIFT, 846 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 847 SOC_DAPM_SINGLE("Mixin Left Invert Switch", DA7213_MIXOUT_L_SELECT, 848 DA7213_MIXOUT_L_MIX_SELECT_MIXIN_L_INVERTED_SHIFT, 849 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 850 SOC_DAPM_SINGLE("Mixin Right Invert Switch", DA7213_MIXOUT_L_SELECT, 851 DA7213_MIXOUT_L_MIX_SELECT_MIXIN_R_INVERTED_SHIFT, 852 DA7213_MIXOUT_L_MIX_SELECT_MAX, DA7213_NO_INVERT), 853 }; 854 855 /* Mixout Right */ 856 static const struct snd_kcontrol_new da7213_dapm_mixoutr_controls[] = { 857 SOC_DAPM_SINGLE("Aux Right Switch", DA7213_MIXOUT_R_SELECT, 858 DA7213_MIXOUT_R_MIX_SELECT_AUX_R_SHIFT, 859 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 860 SOC_DAPM_SINGLE("Mixin Right Switch", DA7213_MIXOUT_R_SELECT, 861 DA7213_MIXOUT_R_MIX_SELECT_MIXIN_R_SHIFT, 862 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 863 SOC_DAPM_SINGLE("Mixin Left Switch", DA7213_MIXOUT_R_SELECT, 864 DA7213_MIXOUT_R_MIX_SELECT_MIXIN_L_SHIFT, 865 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 866 SOC_DAPM_SINGLE("DAC Right Switch", DA7213_MIXOUT_R_SELECT, 867 DA7213_MIXOUT_R_MIX_SELECT_DAC_R_SHIFT, 868 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 869 SOC_DAPM_SINGLE("Aux Right Invert Switch", DA7213_MIXOUT_R_SELECT, 870 DA7213_MIXOUT_R_MIX_SELECT_AUX_R_INVERTED_SHIFT, 871 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 872 SOC_DAPM_SINGLE("Mixin Right Invert Switch", DA7213_MIXOUT_R_SELECT, 873 DA7213_MIXOUT_R_MIX_SELECT_MIXIN_R_INVERTED_SHIFT, 874 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 875 SOC_DAPM_SINGLE("Mixin Left Invert Switch", DA7213_MIXOUT_R_SELECT, 876 DA7213_MIXOUT_R_MIX_SELECT_MIXIN_L_INVERTED_SHIFT, 877 DA7213_MIXOUT_R_MIX_SELECT_MAX, DA7213_NO_INVERT), 878 }; 879 880 881 /* 882 * DAPM Events 883 */ 884 885 static int da7213_dai_event(struct snd_soc_dapm_widget *w, 886 struct snd_kcontrol *kcontrol, int event) 887 { 888 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); 889 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 890 u8 pll_ctrl, pll_status; 891 int i = 0; 892 bool srm_lock = false; 893 894 switch (event) { 895 case SND_SOC_DAPM_PRE_PMU: 896 /* Enable DAI clks for master mode */ 897 if (da7213->master) 898 snd_soc_component_update_bits(component, DA7213_DAI_CLK_MODE, 899 DA7213_DAI_CLK_EN_MASK, 900 DA7213_DAI_CLK_EN_MASK); 901 902 /* PC synchronised to DAI */ 903 snd_soc_component_update_bits(component, DA7213_PC_COUNT, 904 DA7213_PC_FREERUN_MASK, 0); 905 906 /* If SRM not enabled then nothing more to do */ 907 pll_ctrl = snd_soc_component_read(component, DA7213_PLL_CTRL); 908 if (!(pll_ctrl & DA7213_PLL_SRM_EN)) 909 return 0; 910 911 /* Assist 32KHz mode PLL lock */ 912 if (pll_ctrl & DA7213_PLL_32K_MODE) { 913 snd_soc_component_write(component, 0xF0, 0x8B); 914 snd_soc_component_write(component, 0xF2, 0x03); 915 snd_soc_component_write(component, 0xF0, 0x00); 916 } 917 918 /* Check SRM has locked */ 919 do { 920 pll_status = snd_soc_component_read(component, DA7213_PLL_STATUS); 921 if (pll_status & DA7213_PLL_SRM_LOCK) { 922 srm_lock = true; 923 } else { 924 ++i; 925 msleep(50); 926 } 927 } while ((i < DA7213_SRM_CHECK_RETRIES) && (!srm_lock)); 928 929 if (!srm_lock) 930 dev_warn(component->dev, "SRM failed to lock\n"); 931 932 return 0; 933 case SND_SOC_DAPM_POST_PMD: 934 /* Revert 32KHz PLL lock udpates if applied previously */ 935 pll_ctrl = snd_soc_component_read(component, DA7213_PLL_CTRL); 936 if (pll_ctrl & DA7213_PLL_32K_MODE) { 937 snd_soc_component_write(component, 0xF0, 0x8B); 938 snd_soc_component_write(component, 0xF2, 0x01); 939 snd_soc_component_write(component, 0xF0, 0x00); 940 } 941 942 /* PC free-running */ 943 snd_soc_component_update_bits(component, DA7213_PC_COUNT, 944 DA7213_PC_FREERUN_MASK, 945 DA7213_PC_FREERUN_MASK); 946 947 /* Disable DAI clks if in master mode */ 948 if (da7213->master) 949 snd_soc_component_update_bits(component, DA7213_DAI_CLK_MODE, 950 DA7213_DAI_CLK_EN_MASK, 0); 951 return 0; 952 default: 953 return -EINVAL; 954 } 955 } 956 957 958 /* 959 * DAPM widgets 960 */ 961 962 static const struct snd_soc_dapm_widget da7213_dapm_widgets[] = { 963 /* 964 * Power Supply 965 */ 966 SND_SOC_DAPM_REGULATOR_SUPPLY("VDDMIC", 0, 0), 967 968 /* 969 * Input & Output 970 */ 971 972 /* Use a supply here as this controls both input & output DAIs */ 973 SND_SOC_DAPM_SUPPLY("DAI", DA7213_DAI_CTRL, DA7213_DAI_EN_SHIFT, 974 DA7213_NO_INVERT, da7213_dai_event, 975 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD), 976 977 /* 978 * Input 979 */ 980 981 /* Input Lines */ 982 SND_SOC_DAPM_INPUT("MIC1"), 983 SND_SOC_DAPM_INPUT("MIC2"), 984 SND_SOC_DAPM_INPUT("AUXL"), 985 SND_SOC_DAPM_INPUT("AUXR"), 986 987 /* MUXs for Mic PGA source selection */ 988 SND_SOC_DAPM_MUX("Mic 1 Amp Source MUX", SND_SOC_NOPM, 0, 0, 989 &da7213_mic_1_amp_in_sel_mux), 990 SND_SOC_DAPM_MUX("Mic 2 Amp Source MUX", SND_SOC_NOPM, 0, 0, 991 &da7213_mic_2_amp_in_sel_mux), 992 993 /* Input PGAs */ 994 SND_SOC_DAPM_PGA("Mic 1 PGA", DA7213_MIC_1_CTRL, DA7213_AMP_EN_SHIFT, 995 DA7213_NO_INVERT, NULL, 0), 996 SND_SOC_DAPM_PGA("Mic 2 PGA", DA7213_MIC_2_CTRL, DA7213_AMP_EN_SHIFT, 997 DA7213_NO_INVERT, NULL, 0), 998 SND_SOC_DAPM_PGA("Aux Left PGA", DA7213_AUX_L_CTRL, DA7213_AMP_EN_SHIFT, 999 DA7213_NO_INVERT, NULL, 0), 1000 SND_SOC_DAPM_PGA("Aux Right PGA", DA7213_AUX_R_CTRL, 1001 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1002 SND_SOC_DAPM_PGA("Mixin Left PGA", DA7213_MIXIN_L_CTRL, 1003 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1004 SND_SOC_DAPM_PGA("Mixin Right PGA", DA7213_MIXIN_R_CTRL, 1005 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1006 1007 /* Mic Biases */ 1008 SND_SOC_DAPM_SUPPLY("Mic Bias 1", DA7213_MICBIAS_CTRL, 1009 DA7213_MICBIAS1_EN_SHIFT, DA7213_NO_INVERT, 1010 NULL, 0), 1011 SND_SOC_DAPM_SUPPLY("Mic Bias 2", DA7213_MICBIAS_CTRL, 1012 DA7213_MICBIAS2_EN_SHIFT, DA7213_NO_INVERT, 1013 NULL, 0), 1014 1015 /* Input Mixers */ 1016 SND_SOC_DAPM_MIXER("Mixin Left", SND_SOC_NOPM, 0, 0, 1017 &da7213_dapm_mixinl_controls[0], 1018 ARRAY_SIZE(da7213_dapm_mixinl_controls)), 1019 SND_SOC_DAPM_MIXER("Mixin Right", SND_SOC_NOPM, 0, 0, 1020 &da7213_dapm_mixinr_controls[0], 1021 ARRAY_SIZE(da7213_dapm_mixinr_controls)), 1022 1023 /* ADCs */ 1024 SND_SOC_DAPM_ADC("ADC Left", NULL, DA7213_ADC_L_CTRL, 1025 DA7213_ADC_EN_SHIFT, DA7213_NO_INVERT), 1026 SND_SOC_DAPM_ADC("ADC Right", NULL, DA7213_ADC_R_CTRL, 1027 DA7213_ADC_EN_SHIFT, DA7213_NO_INVERT), 1028 1029 /* DAI */ 1030 SND_SOC_DAPM_MUX("DAI Left Source MUX", SND_SOC_NOPM, 0, 0, 1031 &da7213_dai_l_src_mux), 1032 SND_SOC_DAPM_MUX("DAI Right Source MUX", SND_SOC_NOPM, 0, 0, 1033 &da7213_dai_r_src_mux), 1034 SND_SOC_DAPM_AIF_OUT("DAIOUTL", "Capture", 0, SND_SOC_NOPM, 0, 0), 1035 SND_SOC_DAPM_AIF_OUT("DAIOUTR", "Capture", 1, SND_SOC_NOPM, 0, 0), 1036 1037 /* 1038 * Output 1039 */ 1040 1041 /* DAI */ 1042 SND_SOC_DAPM_AIF_IN("DAIINL", "Playback", 0, SND_SOC_NOPM, 0, 0), 1043 SND_SOC_DAPM_AIF_IN("DAIINR", "Playback", 1, SND_SOC_NOPM, 0, 0), 1044 SND_SOC_DAPM_MUX("DAC Left Source MUX", SND_SOC_NOPM, 0, 0, 1045 &da7213_dac_l_src_mux), 1046 SND_SOC_DAPM_MUX("DAC Right Source MUX", SND_SOC_NOPM, 0, 0, 1047 &da7213_dac_r_src_mux), 1048 1049 /* DACs */ 1050 SND_SOC_DAPM_DAC("DAC Left", NULL, DA7213_DAC_L_CTRL, 1051 DA7213_DAC_EN_SHIFT, DA7213_NO_INVERT), 1052 SND_SOC_DAPM_DAC("DAC Right", NULL, DA7213_DAC_R_CTRL, 1053 DA7213_DAC_EN_SHIFT, DA7213_NO_INVERT), 1054 1055 /* Output Mixers */ 1056 SND_SOC_DAPM_MIXER("Mixout Left", SND_SOC_NOPM, 0, 0, 1057 &da7213_dapm_mixoutl_controls[0], 1058 ARRAY_SIZE(da7213_dapm_mixoutl_controls)), 1059 SND_SOC_DAPM_MIXER("Mixout Right", SND_SOC_NOPM, 0, 0, 1060 &da7213_dapm_mixoutr_controls[0], 1061 ARRAY_SIZE(da7213_dapm_mixoutr_controls)), 1062 1063 /* Output PGAs */ 1064 SND_SOC_DAPM_PGA("Mixout Left PGA", DA7213_MIXOUT_L_CTRL, 1065 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1066 SND_SOC_DAPM_PGA("Mixout Right PGA", DA7213_MIXOUT_R_CTRL, 1067 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1068 SND_SOC_DAPM_PGA("Lineout PGA", DA7213_LINE_CTRL, DA7213_AMP_EN_SHIFT, 1069 DA7213_NO_INVERT, NULL, 0), 1070 SND_SOC_DAPM_PGA("Headphone Left PGA", DA7213_HP_L_CTRL, 1071 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1072 SND_SOC_DAPM_PGA("Headphone Right PGA", DA7213_HP_R_CTRL, 1073 DA7213_AMP_EN_SHIFT, DA7213_NO_INVERT, NULL, 0), 1074 1075 /* Charge Pump */ 1076 SND_SOC_DAPM_SUPPLY("Charge Pump", DA7213_CP_CTRL, DA7213_CP_EN_SHIFT, 1077 DA7213_NO_INVERT, NULL, 0), 1078 1079 /* Output Lines */ 1080 SND_SOC_DAPM_OUTPUT("HPL"), 1081 SND_SOC_DAPM_OUTPUT("HPR"), 1082 SND_SOC_DAPM_OUTPUT("LINE"), 1083 }; 1084 1085 1086 /* 1087 * DAPM audio route definition 1088 */ 1089 1090 static const struct snd_soc_dapm_route da7213_audio_map[] = { 1091 /* Dest Connecting Widget source */ 1092 1093 /* Input path */ 1094 {"Mic Bias 1", NULL, "VDDMIC"}, 1095 {"Mic Bias 2", NULL, "VDDMIC"}, 1096 1097 {"MIC1", NULL, "Mic Bias 1"}, 1098 {"MIC2", NULL, "Mic Bias 2"}, 1099 1100 {"Mic 1 Amp Source MUX", "Differential", "MIC1"}, 1101 {"Mic 1 Amp Source MUX", "MIC_P", "MIC1"}, 1102 {"Mic 1 Amp Source MUX", "MIC_N", "MIC1"}, 1103 1104 {"Mic 2 Amp Source MUX", "Differential", "MIC2"}, 1105 {"Mic 2 Amp Source MUX", "MIC_P", "MIC2"}, 1106 {"Mic 2 Amp Source MUX", "MIC_N", "MIC2"}, 1107 1108 {"Mic 1 PGA", NULL, "Mic 1 Amp Source MUX"}, 1109 {"Mic 2 PGA", NULL, "Mic 2 Amp Source MUX"}, 1110 1111 {"Aux Left PGA", NULL, "AUXL"}, 1112 {"Aux Right PGA", NULL, "AUXR"}, 1113 1114 {"Mixin Left", "Aux Left Switch", "Aux Left PGA"}, 1115 {"Mixin Left", "Mic 1 Switch", "Mic 1 PGA"}, 1116 {"Mixin Left", "Mic 2 Switch", "Mic 2 PGA"}, 1117 {"Mixin Left", "Mixin Right Switch", "Mixin Right PGA"}, 1118 1119 {"Mixin Right", "Aux Right Switch", "Aux Right PGA"}, 1120 {"Mixin Right", "Mic 2 Switch", "Mic 2 PGA"}, 1121 {"Mixin Right", "Mic 1 Switch", "Mic 1 PGA"}, 1122 {"Mixin Right", "Mixin Left Switch", "Mixin Left PGA"}, 1123 1124 {"Mixin Left PGA", NULL, "Mixin Left"}, 1125 {"ADC Left", NULL, "Mixin Left PGA"}, 1126 1127 {"Mixin Right PGA", NULL, "Mixin Right"}, 1128 {"ADC Right", NULL, "Mixin Right PGA"}, 1129 1130 {"DAI Left Source MUX", "ADC Left", "ADC Left"}, 1131 {"DAI Left Source MUX", "ADC Right", "ADC Right"}, 1132 {"DAI Left Source MUX", "DAI Input Left", "DAIINL"}, 1133 {"DAI Left Source MUX", "DAI Input Right", "DAIINR"}, 1134 1135 {"DAI Right Source MUX", "ADC Left", "ADC Left"}, 1136 {"DAI Right Source MUX", "ADC Right", "ADC Right"}, 1137 {"DAI Right Source MUX", "DAI Input Left", "DAIINL"}, 1138 {"DAI Right Source MUX", "DAI Input Right", "DAIINR"}, 1139 1140 {"DAIOUTL", NULL, "DAI Left Source MUX"}, 1141 {"DAIOUTR", NULL, "DAI Right Source MUX"}, 1142 1143 {"DAIOUTL", NULL, "DAI"}, 1144 {"DAIOUTR", NULL, "DAI"}, 1145 1146 /* Output path */ 1147 {"DAIINL", NULL, "DAI"}, 1148 {"DAIINR", NULL, "DAI"}, 1149 1150 {"DAC Left Source MUX", "ADC Output Left", "ADC Left"}, 1151 {"DAC Left Source MUX", "ADC Output Right", "ADC Right"}, 1152 {"DAC Left Source MUX", "DAI Input Left", "DAIINL"}, 1153 {"DAC Left Source MUX", "DAI Input Right", "DAIINR"}, 1154 1155 {"DAC Right Source MUX", "ADC Output Left", "ADC Left"}, 1156 {"DAC Right Source MUX", "ADC Output Right", "ADC Right"}, 1157 {"DAC Right Source MUX", "DAI Input Left", "DAIINL"}, 1158 {"DAC Right Source MUX", "DAI Input Right", "DAIINR"}, 1159 1160 {"DAC Left", NULL, "DAC Left Source MUX"}, 1161 {"DAC Right", NULL, "DAC Right Source MUX"}, 1162 1163 {"Mixout Left", "Aux Left Switch", "Aux Left PGA"}, 1164 {"Mixout Left", "Mixin Left Switch", "Mixin Left PGA"}, 1165 {"Mixout Left", "Mixin Right Switch", "Mixin Right PGA"}, 1166 {"Mixout Left", "DAC Left Switch", "DAC Left"}, 1167 {"Mixout Left", "Aux Left Invert Switch", "Aux Left PGA"}, 1168 {"Mixout Left", "Mixin Left Invert Switch", "Mixin Left PGA"}, 1169 {"Mixout Left", "Mixin Right Invert Switch", "Mixin Right PGA"}, 1170 1171 {"Mixout Right", "Aux Right Switch", "Aux Right PGA"}, 1172 {"Mixout Right", "Mixin Right Switch", "Mixin Right PGA"}, 1173 {"Mixout Right", "Mixin Left Switch", "Mixin Left PGA"}, 1174 {"Mixout Right", "DAC Right Switch", "DAC Right"}, 1175 {"Mixout Right", "Aux Right Invert Switch", "Aux Right PGA"}, 1176 {"Mixout Right", "Mixin Right Invert Switch", "Mixin Right PGA"}, 1177 {"Mixout Right", "Mixin Left Invert Switch", "Mixin Left PGA"}, 1178 1179 {"Mixout Left PGA", NULL, "Mixout Left"}, 1180 {"Mixout Right PGA", NULL, "Mixout Right"}, 1181 1182 {"Headphone Left PGA", NULL, "Mixout Left PGA"}, 1183 {"Headphone Left PGA", NULL, "Charge Pump"}, 1184 {"HPL", NULL, "Headphone Left PGA"}, 1185 1186 {"Headphone Right PGA", NULL, "Mixout Right PGA"}, 1187 {"Headphone Right PGA", NULL, "Charge Pump"}, 1188 {"HPR", NULL, "Headphone Right PGA"}, 1189 1190 {"Lineout PGA", NULL, "Mixout Right PGA"}, 1191 {"LINE", NULL, "Lineout PGA"}, 1192 }; 1193 1194 static const struct reg_default da7213_reg_defaults[] = { 1195 { DA7213_DIG_ROUTING_DAI, 0x10 }, 1196 { DA7213_SR, 0x0A }, 1197 { DA7213_REFERENCES, 0x80 }, 1198 { DA7213_PLL_FRAC_TOP, 0x00 }, 1199 { DA7213_PLL_FRAC_BOT, 0x00 }, 1200 { DA7213_PLL_INTEGER, 0x20 }, 1201 { DA7213_PLL_CTRL, 0x0C }, 1202 { DA7213_DAI_CLK_MODE, 0x01 }, 1203 { DA7213_DAI_CTRL, 0x08 }, 1204 { DA7213_DIG_ROUTING_DAC, 0x32 }, 1205 { DA7213_AUX_L_GAIN, 0x35 }, 1206 { DA7213_AUX_R_GAIN, 0x35 }, 1207 { DA7213_MIXIN_L_SELECT, 0x00 }, 1208 { DA7213_MIXIN_R_SELECT, 0x00 }, 1209 { DA7213_MIXIN_L_GAIN, 0x03 }, 1210 { DA7213_MIXIN_R_GAIN, 0x03 }, 1211 { DA7213_ADC_L_GAIN, 0x6F }, 1212 { DA7213_ADC_R_GAIN, 0x6F }, 1213 { DA7213_ADC_FILTERS1, 0x80 }, 1214 { DA7213_MIC_1_GAIN, 0x01 }, 1215 { DA7213_MIC_2_GAIN, 0x01 }, 1216 { DA7213_DAC_FILTERS5, 0x00 }, 1217 { DA7213_DAC_FILTERS2, 0x88 }, 1218 { DA7213_DAC_FILTERS3, 0x88 }, 1219 { DA7213_DAC_FILTERS4, 0x08 }, 1220 { DA7213_DAC_FILTERS1, 0x80 }, 1221 { DA7213_DAC_L_GAIN, 0x6F }, 1222 { DA7213_DAC_R_GAIN, 0x6F }, 1223 { DA7213_CP_CTRL, 0x61 }, 1224 { DA7213_HP_L_GAIN, 0x39 }, 1225 { DA7213_HP_R_GAIN, 0x39 }, 1226 { DA7213_LINE_GAIN, 0x30 }, 1227 { DA7213_MIXOUT_L_SELECT, 0x00 }, 1228 { DA7213_MIXOUT_R_SELECT, 0x00 }, 1229 { DA7213_SYSTEM_MODES_INPUT, 0x00 }, 1230 { DA7213_SYSTEM_MODES_OUTPUT, 0x00 }, 1231 { DA7213_AUX_L_CTRL, 0x44 }, 1232 { DA7213_AUX_R_CTRL, 0x44 }, 1233 { DA7213_MICBIAS_CTRL, 0x11 }, 1234 { DA7213_MIC_1_CTRL, 0x40 }, 1235 { DA7213_MIC_2_CTRL, 0x40 }, 1236 { DA7213_MIXIN_L_CTRL, 0x40 }, 1237 { DA7213_MIXIN_R_CTRL, 0x40 }, 1238 { DA7213_ADC_L_CTRL, 0x40 }, 1239 { DA7213_ADC_R_CTRL, 0x40 }, 1240 { DA7213_DAC_L_CTRL, 0x48 }, 1241 { DA7213_DAC_R_CTRL, 0x40 }, 1242 { DA7213_HP_L_CTRL, 0x41 }, 1243 { DA7213_HP_R_CTRL, 0x40 }, 1244 { DA7213_LINE_CTRL, 0x40 }, 1245 { DA7213_MIXOUT_L_CTRL, 0x10 }, 1246 { DA7213_MIXOUT_R_CTRL, 0x10 }, 1247 { DA7213_LDO_CTRL, 0x00 }, 1248 { DA7213_IO_CTRL, 0x00 }, 1249 { DA7213_GAIN_RAMP_CTRL, 0x00}, 1250 { DA7213_MIC_CONFIG, 0x00 }, 1251 { DA7213_PC_COUNT, 0x00 }, 1252 { DA7213_CP_VOL_THRESHOLD1, 0x32 }, 1253 { DA7213_CP_DELAY, 0x95 }, 1254 { DA7213_CP_DETECTOR, 0x00 }, 1255 { DA7213_DAI_OFFSET, 0x00 }, 1256 { DA7213_DIG_CTRL, 0x00 }, 1257 { DA7213_ALC_CTRL2, 0x00 }, 1258 { DA7213_ALC_CTRL3, 0x00 }, 1259 { DA7213_ALC_NOISE, 0x3F }, 1260 { DA7213_ALC_TARGET_MIN, 0x3F }, 1261 { DA7213_ALC_TARGET_MAX, 0x00 }, 1262 { DA7213_ALC_GAIN_LIMITS, 0xFF }, 1263 { DA7213_ALC_ANA_GAIN_LIMITS, 0x71 }, 1264 { DA7213_ALC_ANTICLIP_CTRL, 0x00 }, 1265 { DA7213_ALC_ANTICLIP_LEVEL, 0x00 }, 1266 { DA7213_ALC_OFFSET_MAN_M_L, 0x00 }, 1267 { DA7213_ALC_OFFSET_MAN_U_L, 0x00 }, 1268 { DA7213_ALC_OFFSET_MAN_M_R, 0x00 }, 1269 { DA7213_ALC_OFFSET_MAN_U_R, 0x00 }, 1270 { DA7213_ALC_CIC_OP_LVL_CTRL, 0x00 }, 1271 { DA7213_DAC_NG_SETUP_TIME, 0x00 }, 1272 { DA7213_DAC_NG_OFF_THRESHOLD, 0x00 }, 1273 { DA7213_DAC_NG_ON_THRESHOLD, 0x00 }, 1274 { DA7213_DAC_NG_CTRL, 0x00 }, 1275 }; 1276 1277 static bool da7213_volatile_register(struct device *dev, unsigned int reg) 1278 { 1279 switch (reg) { 1280 case DA7213_STATUS1: 1281 case DA7213_PLL_STATUS: 1282 case DA7213_AUX_L_GAIN_STATUS: 1283 case DA7213_AUX_R_GAIN_STATUS: 1284 case DA7213_MIC_1_GAIN_STATUS: 1285 case DA7213_MIC_2_GAIN_STATUS: 1286 case DA7213_MIXIN_L_GAIN_STATUS: 1287 case DA7213_MIXIN_R_GAIN_STATUS: 1288 case DA7213_ADC_L_GAIN_STATUS: 1289 case DA7213_ADC_R_GAIN_STATUS: 1290 case DA7213_DAC_L_GAIN_STATUS: 1291 case DA7213_DAC_R_GAIN_STATUS: 1292 case DA7213_HP_L_GAIN_STATUS: 1293 case DA7213_HP_R_GAIN_STATUS: 1294 case DA7213_LINE_GAIN_STATUS: 1295 case DA7213_ALC_CTRL1: 1296 case DA7213_ALC_OFFSET_AUTO_M_L: 1297 case DA7213_ALC_OFFSET_AUTO_U_L: 1298 case DA7213_ALC_OFFSET_AUTO_M_R: 1299 case DA7213_ALC_OFFSET_AUTO_U_R: 1300 case DA7213_ALC_CIC_OP_LVL_DATA: 1301 return true; 1302 default: 1303 return false; 1304 } 1305 } 1306 1307 static int da7213_hw_params(struct snd_pcm_substream *substream, 1308 struct snd_pcm_hw_params *params, 1309 struct snd_soc_dai *dai) 1310 { 1311 struct snd_soc_component *component = dai->component; 1312 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1313 u8 dai_clk_mode = DA7213_DAI_BCLKS_PER_WCLK_64; 1314 u8 dai_ctrl = 0; 1315 u8 fs; 1316 1317 /* Set channels */ 1318 switch (params_channels(params)) { 1319 case 1: 1320 if (da7213->fmt != DA7213_DAI_FORMAT_DSP) { 1321 dev_err(component->dev, "Mono supported only in DSP mode\n"); 1322 return -EINVAL; 1323 } 1324 dai_ctrl |= DA7213_DAI_MONO_MODE_EN; 1325 break; 1326 case 2: 1327 dai_ctrl &= ~(DA7213_DAI_MONO_MODE_EN); 1328 break; 1329 default: 1330 return -EINVAL; 1331 } 1332 1333 /* Set DAI format */ 1334 switch (params_width(params)) { 1335 case 16: 1336 dai_ctrl |= DA7213_DAI_WORD_LENGTH_S16_LE; 1337 dai_clk_mode = DA7213_DAI_BCLKS_PER_WCLK_32; /* 32bit for 1ch and 2ch */ 1338 break; 1339 case 20: 1340 dai_ctrl |= DA7213_DAI_WORD_LENGTH_S20_LE; 1341 break; 1342 case 24: 1343 dai_ctrl |= DA7213_DAI_WORD_LENGTH_S24_LE; 1344 break; 1345 case 32: 1346 dai_ctrl |= DA7213_DAI_WORD_LENGTH_S32_LE; 1347 break; 1348 default: 1349 return -EINVAL; 1350 } 1351 1352 /* Set sampling rate */ 1353 switch (params_rate(params)) { 1354 case 8000: 1355 fs = DA7213_SR_8000; 1356 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1357 break; 1358 case 11025: 1359 fs = DA7213_SR_11025; 1360 da7213->out_rate = DA7213_PLL_FREQ_OUT_90316800; 1361 break; 1362 case 12000: 1363 fs = DA7213_SR_12000; 1364 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1365 break; 1366 case 16000: 1367 fs = DA7213_SR_16000; 1368 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1369 break; 1370 case 22050: 1371 fs = DA7213_SR_22050; 1372 da7213->out_rate = DA7213_PLL_FREQ_OUT_90316800; 1373 break; 1374 case 32000: 1375 fs = DA7213_SR_32000; 1376 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1377 break; 1378 case 44100: 1379 fs = DA7213_SR_44100; 1380 da7213->out_rate = DA7213_PLL_FREQ_OUT_90316800; 1381 break; 1382 case 48000: 1383 fs = DA7213_SR_48000; 1384 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1385 break; 1386 case 88200: 1387 fs = DA7213_SR_88200; 1388 da7213->out_rate = DA7213_PLL_FREQ_OUT_90316800; 1389 break; 1390 case 96000: 1391 fs = DA7213_SR_96000; 1392 da7213->out_rate = DA7213_PLL_FREQ_OUT_98304000; 1393 break; 1394 default: 1395 return -EINVAL; 1396 } 1397 1398 snd_soc_component_update_bits(component, DA7213_DAI_CLK_MODE, 1399 DA7213_DAI_BCLKS_PER_WCLK_MASK, dai_clk_mode); 1400 1401 snd_soc_component_update_bits(component, DA7213_DAI_CTRL, 1402 DA7213_DAI_WORD_LENGTH_MASK | DA7213_DAI_MONO_MODE_MASK, dai_ctrl); 1403 snd_soc_component_write(component, DA7213_SR, fs); 1404 1405 return 0; 1406 } 1407 1408 static int da7213_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) 1409 { 1410 struct snd_soc_component *component = codec_dai->component; 1411 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1412 u8 dai_clk_mode = 0, dai_ctrl = 0; 1413 u8 dai_offset = 0; 1414 1415 /* Set master/slave mode */ 1416 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 1417 case SND_SOC_DAIFMT_CBP_CFP: 1418 da7213->master = true; 1419 break; 1420 case SND_SOC_DAIFMT_CBC_CFC: 1421 da7213->master = false; 1422 break; 1423 default: 1424 return -EINVAL; 1425 } 1426 1427 /* Set clock normal/inverted */ 1428 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 1429 case SND_SOC_DAIFMT_I2S: 1430 case SND_SOC_DAIFMT_LEFT_J: 1431 case SND_SOC_DAIFMT_RIGHT_J: 1432 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 1433 case SND_SOC_DAIFMT_NB_NF: 1434 break; 1435 case SND_SOC_DAIFMT_NB_IF: 1436 dai_clk_mode |= DA7213_DAI_WCLK_POL_INV; 1437 break; 1438 case SND_SOC_DAIFMT_IB_NF: 1439 dai_clk_mode |= DA7213_DAI_CLK_POL_INV; 1440 break; 1441 case SND_SOC_DAIFMT_IB_IF: 1442 dai_clk_mode |= DA7213_DAI_WCLK_POL_INV | 1443 DA7213_DAI_CLK_POL_INV; 1444 break; 1445 default: 1446 return -EINVAL; 1447 } 1448 break; 1449 case SND_SOC_DAIFMT_DSP_A: 1450 case SND_SOC_DAIFMT_DSP_B: 1451 /* The bclk is inverted wrt ASoC conventions */ 1452 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 1453 case SND_SOC_DAIFMT_NB_NF: 1454 dai_clk_mode |= DA7213_DAI_CLK_POL_INV; 1455 break; 1456 case SND_SOC_DAIFMT_NB_IF: 1457 dai_clk_mode |= DA7213_DAI_WCLK_POL_INV | 1458 DA7213_DAI_CLK_POL_INV; 1459 break; 1460 case SND_SOC_DAIFMT_IB_NF: 1461 break; 1462 case SND_SOC_DAIFMT_IB_IF: 1463 dai_clk_mode |= DA7213_DAI_WCLK_POL_INV; 1464 break; 1465 default: 1466 return -EINVAL; 1467 } 1468 break; 1469 default: 1470 return -EINVAL; 1471 } 1472 1473 /* Only I2S is supported */ 1474 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 1475 case SND_SOC_DAIFMT_I2S: 1476 dai_ctrl |= DA7213_DAI_FORMAT_I2S_MODE; 1477 da7213->fmt = DA7213_DAI_FORMAT_I2S_MODE; 1478 break; 1479 case SND_SOC_DAIFMT_LEFT_J: 1480 dai_ctrl |= DA7213_DAI_FORMAT_LEFT_J; 1481 da7213->fmt = DA7213_DAI_FORMAT_LEFT_J; 1482 break; 1483 case SND_SOC_DAIFMT_RIGHT_J: 1484 dai_ctrl |= DA7213_DAI_FORMAT_RIGHT_J; 1485 da7213->fmt = DA7213_DAI_FORMAT_RIGHT_J; 1486 break; 1487 case SND_SOC_DAIFMT_DSP_A: /* L data MSB after FRM LRC */ 1488 dai_ctrl |= DA7213_DAI_FORMAT_DSP; 1489 dai_offset = 1; 1490 da7213->fmt = DA7213_DAI_FORMAT_DSP; 1491 break; 1492 case SND_SOC_DAIFMT_DSP_B: /* L data MSB during FRM LRC */ 1493 dai_ctrl |= DA7213_DAI_FORMAT_DSP; 1494 da7213->fmt = DA7213_DAI_FORMAT_DSP; 1495 break; 1496 default: 1497 return -EINVAL; 1498 } 1499 1500 /* By default only 64 BCLK per WCLK is supported */ 1501 dai_clk_mode |= DA7213_DAI_BCLKS_PER_WCLK_64; 1502 1503 snd_soc_component_update_bits(component, DA7213_DAI_CLK_MODE, 1504 DA7213_DAI_BCLKS_PER_WCLK_MASK | 1505 DA7213_DAI_CLK_POL_MASK | DA7213_DAI_WCLK_POL_MASK, 1506 dai_clk_mode); 1507 snd_soc_component_update_bits(component, DA7213_DAI_CTRL, DA7213_DAI_FORMAT_MASK, 1508 dai_ctrl); 1509 snd_soc_component_write(component, DA7213_DAI_OFFSET, dai_offset); 1510 1511 return 0; 1512 } 1513 1514 static int da7213_mute(struct snd_soc_dai *dai, int mute, int direction) 1515 { 1516 struct snd_soc_component *component = dai->component; 1517 1518 if (mute) { 1519 snd_soc_component_update_bits(component, DA7213_DAC_L_CTRL, 1520 DA7213_MUTE_EN, DA7213_MUTE_EN); 1521 snd_soc_component_update_bits(component, DA7213_DAC_R_CTRL, 1522 DA7213_MUTE_EN, DA7213_MUTE_EN); 1523 } else { 1524 snd_soc_component_update_bits(component, DA7213_DAC_L_CTRL, 1525 DA7213_MUTE_EN, 0); 1526 snd_soc_component_update_bits(component, DA7213_DAC_R_CTRL, 1527 DA7213_MUTE_EN, 0); 1528 } 1529 1530 return 0; 1531 } 1532 1533 #define DA7213_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 1534 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE) 1535 1536 static int da7213_set_component_sysclk(struct snd_soc_component *component, 1537 int clk_id, int source, 1538 unsigned int freq, int dir) 1539 { 1540 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1541 int ret = 0; 1542 1543 if ((da7213->clk_src == clk_id) && (da7213->mclk_rate == freq)) 1544 return 0; 1545 1546 /* Maybe audio stream is closing. */ 1547 if (freq == 0) 1548 return 0; 1549 1550 if (((freq < da7213->fin_min_rate) && (freq != 32768)) || (freq > 54000000)) { 1551 dev_err(component->dev, "Unsupported MCLK value %d\n", 1552 freq); 1553 return -EINVAL; 1554 } 1555 1556 switch (clk_id) { 1557 case DA7213_CLKSRC_MCLK: 1558 snd_soc_component_update_bits(component, DA7213_PLL_CTRL, 1559 DA7213_PLL_MCLK_SQR_EN, 0); 1560 break; 1561 case DA7213_CLKSRC_MCLK_SQR: 1562 snd_soc_component_update_bits(component, DA7213_PLL_CTRL, 1563 DA7213_PLL_MCLK_SQR_EN, 1564 DA7213_PLL_MCLK_SQR_EN); 1565 break; 1566 default: 1567 dev_err(component->dev, "Unknown clock source %d\n", clk_id); 1568 return -EINVAL; 1569 } 1570 1571 da7213->clk_src = clk_id; 1572 1573 if (da7213->mclk) { 1574 freq = clk_round_rate(da7213->mclk, freq); 1575 ret = clk_set_rate(da7213->mclk, freq); 1576 if (ret) { 1577 dev_err(component->dev, "Failed to set clock rate %d\n", 1578 freq); 1579 return ret; 1580 } 1581 } 1582 1583 da7213->mclk_rate = freq; 1584 1585 return 0; 1586 } 1587 1588 /* Supported PLL input frequencies are 32KHz, 5MHz - 54MHz. */ 1589 static int _da7213_set_component_pll(struct snd_soc_component *component, 1590 int pll_id, int source, 1591 unsigned int fref, unsigned int fout) 1592 { 1593 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1594 1595 u8 pll_ctrl, indiv_bits, indiv; 1596 u8 pll_frac_top, pll_frac_bot, pll_integer; 1597 u32 freq_ref; 1598 u64 frac_div; 1599 1600 /* Workout input divider based on MCLK rate */ 1601 if (da7213->mclk_rate == 32768) { 1602 if (!da7213->master) { 1603 dev_err(component->dev, 1604 "32KHz only valid if codec is clock master\n"); 1605 return -EINVAL; 1606 } 1607 1608 /* 32KHz PLL Mode */ 1609 indiv_bits = DA7213_PLL_INDIV_9_TO_18_MHZ; 1610 indiv = DA7213_PLL_INDIV_9_TO_18_MHZ_VAL; 1611 source = DA7213_SYSCLK_PLL_32KHZ; 1612 freq_ref = 3750000; 1613 1614 } else { 1615 if (da7213->mclk_rate < 5000000) { 1616 dev_err(component->dev, 1617 "PLL input clock %d below valid range\n", 1618 da7213->mclk_rate); 1619 return -EINVAL; 1620 } else if (da7213->mclk_rate <= 9000000) { 1621 indiv_bits = DA7213_PLL_INDIV_5_TO_9_MHZ; 1622 indiv = DA7213_PLL_INDIV_5_TO_9_MHZ_VAL; 1623 } else if (da7213->mclk_rate <= 18000000) { 1624 indiv_bits = DA7213_PLL_INDIV_9_TO_18_MHZ; 1625 indiv = DA7213_PLL_INDIV_9_TO_18_MHZ_VAL; 1626 } else if (da7213->mclk_rate <= 36000000) { 1627 indiv_bits = DA7213_PLL_INDIV_18_TO_36_MHZ; 1628 indiv = DA7213_PLL_INDIV_18_TO_36_MHZ_VAL; 1629 } else if (da7213->mclk_rate <= 54000000) { 1630 indiv_bits = DA7213_PLL_INDIV_36_TO_54_MHZ; 1631 indiv = DA7213_PLL_INDIV_36_TO_54_MHZ_VAL; 1632 } else { 1633 dev_err(component->dev, 1634 "PLL input clock %d above valid range\n", 1635 da7213->mclk_rate); 1636 return -EINVAL; 1637 } 1638 freq_ref = (da7213->mclk_rate / indiv); 1639 } 1640 1641 pll_ctrl = indiv_bits; 1642 1643 /* Configure PLL */ 1644 switch (source) { 1645 case DA7213_SYSCLK_MCLK: 1646 snd_soc_component_update_bits(component, DA7213_PLL_CTRL, 1647 DA7213_PLL_INDIV_MASK | 1648 DA7213_PLL_MODE_MASK, pll_ctrl); 1649 return 0; 1650 case DA7213_SYSCLK_PLL: 1651 break; 1652 case DA7213_SYSCLK_PLL_SRM: 1653 pll_ctrl |= DA7213_PLL_SRM_EN; 1654 fout = DA7213_PLL_FREQ_OUT_94310400; 1655 break; 1656 case DA7213_SYSCLK_PLL_32KHZ: 1657 if (da7213->mclk_rate != 32768) { 1658 dev_err(component->dev, 1659 "32KHz mode only valid with 32KHz MCLK\n"); 1660 return -EINVAL; 1661 } 1662 1663 pll_ctrl |= DA7213_PLL_32K_MODE | DA7213_PLL_SRM_EN; 1664 fout = DA7213_PLL_FREQ_OUT_94310400; 1665 break; 1666 default: 1667 dev_err(component->dev, "Invalid PLL config\n"); 1668 return -EINVAL; 1669 } 1670 1671 /* Calculate dividers for PLL */ 1672 pll_integer = fout / freq_ref; 1673 frac_div = (u64)(fout % freq_ref) * 8192ULL; 1674 do_div(frac_div, freq_ref); 1675 pll_frac_top = (frac_div >> DA7213_BYTE_SHIFT) & DA7213_BYTE_MASK; 1676 pll_frac_bot = (frac_div) & DA7213_BYTE_MASK; 1677 1678 /* Write PLL dividers */ 1679 snd_soc_component_write(component, DA7213_PLL_FRAC_TOP, pll_frac_top); 1680 snd_soc_component_write(component, DA7213_PLL_FRAC_BOT, pll_frac_bot); 1681 snd_soc_component_write(component, DA7213_PLL_INTEGER, pll_integer); 1682 1683 /* Enable PLL */ 1684 pll_ctrl |= DA7213_PLL_EN; 1685 snd_soc_component_update_bits(component, DA7213_PLL_CTRL, 1686 DA7213_PLL_INDIV_MASK | DA7213_PLL_MODE_MASK, 1687 pll_ctrl); 1688 1689 /* Assist 32KHz mode PLL lock */ 1690 if (source == DA7213_SYSCLK_PLL_32KHZ) { 1691 snd_soc_component_write(component, 0xF0, 0x8B); 1692 snd_soc_component_write(component, 0xF1, 0x03); 1693 snd_soc_component_write(component, 0xF1, 0x01); 1694 snd_soc_component_write(component, 0xF0, 0x00); 1695 } 1696 1697 return 0; 1698 } 1699 1700 static int da7213_set_component_pll(struct snd_soc_component *component, 1701 int pll_id, int source, 1702 unsigned int fref, unsigned int fout) 1703 { 1704 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1705 da7213->fixed_clk_auto_pll = false; 1706 1707 return _da7213_set_component_pll(component, pll_id, source, fref, fout); 1708 } 1709 1710 static const u64 da7213_dai_formats = 1711 SND_SOC_POSSIBLE_DAIFMT_I2S | 1712 SND_SOC_POSSIBLE_DAIFMT_LEFT_J | 1713 SND_SOC_POSSIBLE_DAIFMT_RIGHT_J | 1714 SND_SOC_POSSIBLE_DAIFMT_DSP_A | 1715 SND_SOC_POSSIBLE_DAIFMT_DSP_B | 1716 SND_SOC_POSSIBLE_DAIFMT_NB_NF | 1717 SND_SOC_POSSIBLE_DAIFMT_NB_IF | 1718 SND_SOC_POSSIBLE_DAIFMT_IB_NF | 1719 SND_SOC_POSSIBLE_DAIFMT_IB_IF; 1720 1721 /* DAI operations */ 1722 static const struct snd_soc_dai_ops da7213_dai_ops = { 1723 .hw_params = da7213_hw_params, 1724 .set_fmt = da7213_set_dai_fmt, 1725 .mute_stream = da7213_mute, 1726 .no_capture_mute = 1, 1727 .auto_selectable_formats = &da7213_dai_formats, 1728 .num_auto_selectable_formats = 1, 1729 }; 1730 1731 static struct snd_soc_dai_driver da7213_dai = { 1732 .name = "da7213-hifi", 1733 /* Playback Capabilities */ 1734 .playback = { 1735 .stream_name = "Playback", 1736 .channels_min = 1, 1737 .channels_max = 2, 1738 .rates = SNDRV_PCM_RATE_8000_96000, 1739 .formats = DA7213_FORMATS, 1740 }, 1741 /* Capture Capabilities */ 1742 .capture = { 1743 .stream_name = "Capture", 1744 .channels_min = 1, 1745 .channels_max = 2, 1746 .rates = SNDRV_PCM_RATE_8000_96000, 1747 .formats = DA7213_FORMATS, 1748 }, 1749 .ops = &da7213_dai_ops, 1750 .symmetric_rate = 1, 1751 }; 1752 1753 static int da7213_set_auto_pll(struct snd_soc_component *component, bool enable) 1754 { 1755 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1756 int mode; 1757 1758 if (!da7213->fixed_clk_auto_pll) 1759 return 0; 1760 1761 da7213->mclk_rate = clk_get_rate(da7213->mclk); 1762 1763 if (enable) { 1764 /* Slave mode needs SRM for non-harmonic frequencies */ 1765 if (da7213->master) 1766 mode = DA7213_SYSCLK_PLL; 1767 else 1768 mode = DA7213_SYSCLK_PLL_SRM; 1769 1770 /* PLL is not required for harmonic frequencies */ 1771 switch (da7213->out_rate) { 1772 case DA7213_PLL_FREQ_OUT_90316800: 1773 if (da7213->mclk_rate == 11289600 || 1774 da7213->mclk_rate == 22579200 || 1775 da7213->mclk_rate == 45158400) 1776 mode = DA7213_SYSCLK_MCLK; 1777 break; 1778 case DA7213_PLL_FREQ_OUT_98304000: 1779 if (da7213->mclk_rate == 12288000 || 1780 da7213->mclk_rate == 24576000 || 1781 da7213->mclk_rate == 49152000) 1782 mode = DA7213_SYSCLK_MCLK; 1783 1784 break; 1785 default: 1786 return -1; 1787 } 1788 } else { 1789 /* Disable PLL in standby */ 1790 mode = DA7213_SYSCLK_MCLK; 1791 } 1792 1793 return _da7213_set_component_pll(component, 0, mode, 1794 da7213->mclk_rate, da7213->out_rate); 1795 } 1796 1797 static int da7213_set_bias_level(struct snd_soc_component *component, 1798 enum snd_soc_bias_level level) 1799 { 1800 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1801 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component); 1802 int ret; 1803 1804 switch (level) { 1805 case SND_SOC_BIAS_ON: 1806 break; 1807 case SND_SOC_BIAS_PREPARE: 1808 /* Enable MCLK for transition to ON state */ 1809 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_STANDBY) { 1810 if (da7213->mclk) { 1811 ret = clk_prepare_enable(da7213->mclk); 1812 if (ret) { 1813 dev_err(component->dev, 1814 "Failed to enable mclk\n"); 1815 return ret; 1816 } 1817 1818 da7213_set_auto_pll(component, true); 1819 } 1820 } 1821 break; 1822 case SND_SOC_BIAS_STANDBY: 1823 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_OFF) { 1824 /* Enable VMID reference & master bias */ 1825 snd_soc_component_update_bits(component, DA7213_REFERENCES, 1826 DA7213_VMID_EN | DA7213_BIAS_EN, 1827 DA7213_VMID_EN | DA7213_BIAS_EN); 1828 } else { 1829 /* Remove MCLK */ 1830 if (da7213->mclk) { 1831 da7213_set_auto_pll(component, false); 1832 clk_disable_unprepare(da7213->mclk); 1833 } 1834 } 1835 break; 1836 case SND_SOC_BIAS_OFF: 1837 /* Disable VMID reference & master bias */ 1838 snd_soc_component_update_bits(component, DA7213_REFERENCES, 1839 DA7213_VMID_EN | DA7213_BIAS_EN, 0); 1840 break; 1841 } 1842 return 0; 1843 } 1844 1845 #define DA7213_FIN_MIN_RATE (5 * MEGA) 1846 #define DA7212_FIN_MIN_RATE (2 * MEGA) 1847 1848 #if defined(CONFIG_OF) 1849 /* DT */ 1850 static const struct of_device_id da7213_of_match[] = { 1851 { .compatible = "dlg,da7212", .data = (void *)DA7212_FIN_MIN_RATE }, 1852 { .compatible = "dlg,da7213", .data = (void *)DA7213_FIN_MIN_RATE }, 1853 { } 1854 }; 1855 MODULE_DEVICE_TABLE(of, da7213_of_match); 1856 #endif 1857 1858 #ifdef CONFIG_ACPI 1859 static const struct acpi_device_id da7213_acpi_match[] = { 1860 { "DLGS7212", DA7212_FIN_MIN_RATE }, 1861 { "DLGS7213", DA7213_FIN_MIN_RATE }, 1862 { }, 1863 }; 1864 MODULE_DEVICE_TABLE(acpi, da7213_acpi_match); 1865 #endif 1866 1867 static enum da7213_micbias_voltage 1868 da7213_of_micbias_lvl(struct snd_soc_component *component, u32 val) 1869 { 1870 switch (val) { 1871 case 1600: 1872 return DA7213_MICBIAS_1_6V; 1873 case 2200: 1874 return DA7213_MICBIAS_2_2V; 1875 case 2500: 1876 return DA7213_MICBIAS_2_5V; 1877 case 3000: 1878 return DA7213_MICBIAS_3_0V; 1879 default: 1880 dev_warn(component->dev, "Invalid micbias level\n"); 1881 return DA7213_MICBIAS_2_2V; 1882 } 1883 } 1884 1885 static enum da7213_dmic_data_sel 1886 da7213_of_dmic_data_sel(struct snd_soc_component *component, const char *str) 1887 { 1888 if (!strcmp(str, "lrise_rfall")) { 1889 return DA7213_DMIC_DATA_LRISE_RFALL; 1890 } else if (!strcmp(str, "lfall_rrise")) { 1891 return DA7213_DMIC_DATA_LFALL_RRISE; 1892 } else { 1893 dev_warn(component->dev, "Invalid DMIC data select type\n"); 1894 return DA7213_DMIC_DATA_LRISE_RFALL; 1895 } 1896 } 1897 1898 static enum da7213_dmic_samplephase 1899 da7213_of_dmic_samplephase(struct snd_soc_component *component, const char *str) 1900 { 1901 if (!strcmp(str, "on_clkedge")) { 1902 return DA7213_DMIC_SAMPLE_ON_CLKEDGE; 1903 } else if (!strcmp(str, "between_clkedge")) { 1904 return DA7213_DMIC_SAMPLE_BETWEEN_CLKEDGE; 1905 } else { 1906 dev_warn(component->dev, "Invalid DMIC sample phase\n"); 1907 return DA7213_DMIC_SAMPLE_ON_CLKEDGE; 1908 } 1909 } 1910 1911 static enum da7213_dmic_clk_rate 1912 da7213_of_dmic_clkrate(struct snd_soc_component *component, u32 val) 1913 { 1914 switch (val) { 1915 case 1500000: 1916 return DA7213_DMIC_CLK_1_5MHZ; 1917 case 3000000: 1918 return DA7213_DMIC_CLK_3_0MHZ; 1919 default: 1920 dev_warn(component->dev, "Invalid DMIC clock rate\n"); 1921 return DA7213_DMIC_CLK_1_5MHZ; 1922 } 1923 } 1924 1925 static struct da7213_platform_data 1926 *da7213_fw_to_pdata(struct snd_soc_component *component) 1927 { 1928 struct device *dev = component->dev; 1929 struct da7213_platform_data *pdata; 1930 const char *fw_str; 1931 u32 fw_val32; 1932 1933 pdata = devm_kzalloc(component->dev, sizeof(*pdata), GFP_KERNEL); 1934 if (!pdata) 1935 return NULL; 1936 1937 if (device_property_read_u32(dev, "dlg,micbias1-lvl", &fw_val32) >= 0) 1938 pdata->micbias1_lvl = da7213_of_micbias_lvl(component, fw_val32); 1939 else 1940 pdata->micbias1_lvl = DA7213_MICBIAS_2_2V; 1941 1942 if (device_property_read_u32(dev, "dlg,micbias2-lvl", &fw_val32) >= 0) 1943 pdata->micbias2_lvl = da7213_of_micbias_lvl(component, fw_val32); 1944 else 1945 pdata->micbias2_lvl = DA7213_MICBIAS_2_2V; 1946 1947 if (!device_property_read_string(dev, "dlg,dmic-data-sel", &fw_str)) 1948 pdata->dmic_data_sel = da7213_of_dmic_data_sel(component, fw_str); 1949 else 1950 pdata->dmic_data_sel = DA7213_DMIC_DATA_LRISE_RFALL; 1951 1952 if (!device_property_read_string(dev, "dlg,dmic-samplephase", &fw_str)) 1953 pdata->dmic_samplephase = 1954 da7213_of_dmic_samplephase(component, fw_str); 1955 else 1956 pdata->dmic_samplephase = DA7213_DMIC_SAMPLE_ON_CLKEDGE; 1957 1958 if (device_property_read_u32(dev, "dlg,dmic-clkrate", &fw_val32) >= 0) 1959 pdata->dmic_clk_rate = da7213_of_dmic_clkrate(component, fw_val32); 1960 else 1961 pdata->dmic_clk_rate = DA7213_DMIC_CLK_3_0MHZ; 1962 1963 return pdata; 1964 } 1965 1966 static int da7213_probe(struct snd_soc_component *component) 1967 { 1968 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 1969 1970 pm_runtime_get_sync(component->dev); 1971 1972 /* Default to using ALC auto offset calibration mode. */ 1973 snd_soc_component_update_bits(component, DA7213_ALC_CTRL1, 1974 DA7213_ALC_CALIB_MODE_MAN, 0); 1975 da7213->alc_calib_auto = true; 1976 1977 /* Default PC counter to free-running */ 1978 snd_soc_component_update_bits(component, DA7213_PC_COUNT, DA7213_PC_FREERUN_MASK, 1979 DA7213_PC_FREERUN_MASK); 1980 1981 /* Enable all Gain Ramps */ 1982 snd_soc_component_update_bits(component, DA7213_AUX_L_CTRL, 1983 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1984 snd_soc_component_update_bits(component, DA7213_AUX_R_CTRL, 1985 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1986 snd_soc_component_update_bits(component, DA7213_MIXIN_L_CTRL, 1987 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1988 snd_soc_component_update_bits(component, DA7213_MIXIN_R_CTRL, 1989 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1990 snd_soc_component_update_bits(component, DA7213_ADC_L_CTRL, 1991 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1992 snd_soc_component_update_bits(component, DA7213_ADC_R_CTRL, 1993 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1994 snd_soc_component_update_bits(component, DA7213_DAC_L_CTRL, 1995 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1996 snd_soc_component_update_bits(component, DA7213_DAC_R_CTRL, 1997 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 1998 snd_soc_component_update_bits(component, DA7213_HP_L_CTRL, 1999 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 2000 snd_soc_component_update_bits(component, DA7213_HP_R_CTRL, 2001 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 2002 snd_soc_component_update_bits(component, DA7213_LINE_CTRL, 2003 DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN); 2004 2005 /* 2006 * There are two separate control bits for input and output mixers as 2007 * well as headphone and line outs. 2008 * One to enable corresponding amplifier and other to enable its 2009 * output. As amplifier bits are related to power control, they are 2010 * being managed by DAPM while other (non power related) bits are 2011 * enabled here 2012 */ 2013 snd_soc_component_update_bits(component, DA7213_MIXIN_L_CTRL, 2014 DA7213_MIXIN_MIX_EN, DA7213_MIXIN_MIX_EN); 2015 snd_soc_component_update_bits(component, DA7213_MIXIN_R_CTRL, 2016 DA7213_MIXIN_MIX_EN, DA7213_MIXIN_MIX_EN); 2017 2018 snd_soc_component_update_bits(component, DA7213_MIXOUT_L_CTRL, 2019 DA7213_MIXOUT_MIX_EN, DA7213_MIXOUT_MIX_EN); 2020 snd_soc_component_update_bits(component, DA7213_MIXOUT_R_CTRL, 2021 DA7213_MIXOUT_MIX_EN, DA7213_MIXOUT_MIX_EN); 2022 2023 snd_soc_component_update_bits(component, DA7213_HP_L_CTRL, 2024 DA7213_HP_AMP_OE, DA7213_HP_AMP_OE); 2025 snd_soc_component_update_bits(component, DA7213_HP_R_CTRL, 2026 DA7213_HP_AMP_OE, DA7213_HP_AMP_OE); 2027 2028 snd_soc_component_update_bits(component, DA7213_LINE_CTRL, 2029 DA7213_LINE_AMP_OE, DA7213_LINE_AMP_OE); 2030 2031 /* Handle DT/Platform data */ 2032 da7213->pdata = dev_get_platdata(component->dev); 2033 if (!da7213->pdata) 2034 da7213->pdata = da7213_fw_to_pdata(component); 2035 2036 /* Set platform data values */ 2037 if (da7213->pdata) { 2038 struct da7213_platform_data *pdata = da7213->pdata; 2039 u8 micbias_lvl = 0, dmic_cfg = 0; 2040 2041 /* Set Mic Bias voltages */ 2042 switch (pdata->micbias1_lvl) { 2043 case DA7213_MICBIAS_1_6V: 2044 case DA7213_MICBIAS_2_2V: 2045 case DA7213_MICBIAS_2_5V: 2046 case DA7213_MICBIAS_3_0V: 2047 micbias_lvl |= (pdata->micbias1_lvl << 2048 DA7213_MICBIAS1_LEVEL_SHIFT); 2049 break; 2050 } 2051 switch (pdata->micbias2_lvl) { 2052 case DA7213_MICBIAS_1_6V: 2053 case DA7213_MICBIAS_2_2V: 2054 case DA7213_MICBIAS_2_5V: 2055 case DA7213_MICBIAS_3_0V: 2056 micbias_lvl |= (pdata->micbias2_lvl << 2057 DA7213_MICBIAS2_LEVEL_SHIFT); 2058 break; 2059 } 2060 snd_soc_component_update_bits(component, DA7213_MICBIAS_CTRL, 2061 DA7213_MICBIAS1_LEVEL_MASK | 2062 DA7213_MICBIAS2_LEVEL_MASK, micbias_lvl); 2063 2064 /* Set DMIC configuration */ 2065 switch (pdata->dmic_data_sel) { 2066 case DA7213_DMIC_DATA_LFALL_RRISE: 2067 case DA7213_DMIC_DATA_LRISE_RFALL: 2068 dmic_cfg |= (pdata->dmic_data_sel << 2069 DA7213_DMIC_DATA_SEL_SHIFT); 2070 break; 2071 } 2072 switch (pdata->dmic_samplephase) { 2073 case DA7213_DMIC_SAMPLE_ON_CLKEDGE: 2074 case DA7213_DMIC_SAMPLE_BETWEEN_CLKEDGE: 2075 dmic_cfg |= (pdata->dmic_samplephase << 2076 DA7213_DMIC_SAMPLEPHASE_SHIFT); 2077 break; 2078 } 2079 switch (pdata->dmic_clk_rate) { 2080 case DA7213_DMIC_CLK_3_0MHZ: 2081 case DA7213_DMIC_CLK_1_5MHZ: 2082 dmic_cfg |= (pdata->dmic_clk_rate << 2083 DA7213_DMIC_CLK_RATE_SHIFT); 2084 break; 2085 } 2086 snd_soc_component_update_bits(component, DA7213_MIC_CONFIG, 2087 DA7213_DMIC_DATA_SEL_MASK | 2088 DA7213_DMIC_SAMPLEPHASE_MASK | 2089 DA7213_DMIC_CLK_RATE_MASK, dmic_cfg); 2090 } 2091 2092 pm_runtime_put_sync(component->dev); 2093 2094 /* Check if MCLK provided */ 2095 da7213->mclk = devm_clk_get_optional(component->dev, "mclk"); 2096 if (IS_ERR(da7213->mclk)) 2097 return PTR_ERR(da7213->mclk); 2098 if (da7213->mclk) 2099 /* Do automatic PLL handling assuming fixed clock until 2100 * set_pll() has been called. This makes the codec usable 2101 * with the simple-audio-card driver. */ 2102 da7213->fixed_clk_auto_pll = true; 2103 2104 /* Default infinite tone gen, start/stop by Kcontrol */ 2105 snd_soc_component_write(component, DA7213_TONE_GEN_CYCLES, DA7213_BEEP_CYCLES_MASK); 2106 2107 return 0; 2108 } 2109 2110 static int da7213_runtime_suspend(struct device *dev) 2111 { 2112 struct da7213_priv *da7213 = dev_get_drvdata(dev); 2113 2114 regcache_cache_only(da7213->regmap, true); 2115 regcache_mark_dirty(da7213->regmap); 2116 regulator_bulk_disable(DA7213_NUM_SUPPLIES, da7213->supplies); 2117 2118 return 0; 2119 } 2120 2121 static int da7213_runtime_resume(struct device *dev) 2122 { 2123 struct da7213_priv *da7213 = dev_get_drvdata(dev); 2124 int ret; 2125 2126 ret = regulator_bulk_enable(DA7213_NUM_SUPPLIES, da7213->supplies); 2127 if (ret < 0) 2128 return ret; 2129 regcache_cache_only(da7213->regmap, false); 2130 return regcache_sync(da7213->regmap); 2131 } 2132 2133 static int da7213_suspend(struct snd_soc_component *component) 2134 { 2135 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 2136 2137 return da7213_runtime_suspend(da7213->dev); 2138 } 2139 2140 static int da7213_resume(struct snd_soc_component *component) 2141 { 2142 struct da7213_priv *da7213 = snd_soc_component_get_drvdata(component); 2143 2144 return da7213_runtime_resume(da7213->dev); 2145 } 2146 2147 static const struct snd_soc_component_driver soc_component_dev_da7213 = { 2148 .probe = da7213_probe, 2149 .set_bias_level = da7213_set_bias_level, 2150 .controls = da7213_snd_controls, 2151 .num_controls = ARRAY_SIZE(da7213_snd_controls), 2152 .suspend = da7213_suspend, 2153 .resume = da7213_resume, 2154 .dapm_widgets = da7213_dapm_widgets, 2155 .num_dapm_widgets = ARRAY_SIZE(da7213_dapm_widgets), 2156 .dapm_routes = da7213_audio_map, 2157 .num_dapm_routes = ARRAY_SIZE(da7213_audio_map), 2158 .set_sysclk = da7213_set_component_sysclk, 2159 .set_pll = da7213_set_component_pll, 2160 .idle_bias_on = 1, 2161 .use_pmdown_time = 1, 2162 .endianness = 1, 2163 }; 2164 2165 static const struct regmap_config da7213_regmap_config = { 2166 .reg_bits = 8, 2167 .val_bits = 8, 2168 2169 .max_register = DA7213_TONE_GEN_OFF_PER, 2170 .reg_defaults = da7213_reg_defaults, 2171 .num_reg_defaults = ARRAY_SIZE(da7213_reg_defaults), 2172 .volatile_reg = da7213_volatile_register, 2173 .cache_type = REGCACHE_RBTREE, 2174 }; 2175 2176 static void da7213_power_off(void *data) 2177 { 2178 struct da7213_priv *da7213 = data; 2179 regulator_bulk_disable(DA7213_NUM_SUPPLIES, da7213->supplies); 2180 } 2181 2182 static const char *da7213_supply_names[DA7213_NUM_SUPPLIES] = { 2183 [DA7213_SUPPLY_VDDA] = "VDDA", 2184 [DA7213_SUPPLY_VDDIO] = "VDDIO", 2185 }; 2186 2187 static int da7213_i2c_probe(struct i2c_client *i2c) 2188 { 2189 struct da7213_priv *da7213; 2190 int i, ret; 2191 2192 da7213 = devm_kzalloc(&i2c->dev, sizeof(*da7213), GFP_KERNEL); 2193 if (!da7213) 2194 return -ENOMEM; 2195 2196 da7213->fin_min_rate = (uintptr_t)i2c_get_match_data(i2c); 2197 if (!da7213->fin_min_rate) 2198 return -EINVAL; 2199 2200 da7213->dev = &i2c->dev; 2201 2202 i2c_set_clientdata(i2c, da7213); 2203 2204 /* Get required supplies */ 2205 for (i = 0; i < DA7213_NUM_SUPPLIES; ++i) 2206 da7213->supplies[i].supply = da7213_supply_names[i]; 2207 2208 ret = devm_regulator_bulk_get(&i2c->dev, DA7213_NUM_SUPPLIES, 2209 da7213->supplies); 2210 if (ret) { 2211 dev_err(&i2c->dev, "Failed to get supplies: %d\n", ret); 2212 return ret; 2213 } 2214 2215 ret = regulator_bulk_enable(DA7213_NUM_SUPPLIES, da7213->supplies); 2216 if (ret < 0) 2217 return ret; 2218 2219 ret = devm_add_action_or_reset(&i2c->dev, da7213_power_off, da7213); 2220 if (ret < 0) 2221 return ret; 2222 2223 da7213->regmap = devm_regmap_init_i2c(i2c, &da7213_regmap_config); 2224 if (IS_ERR(da7213->regmap)) { 2225 ret = PTR_ERR(da7213->regmap); 2226 dev_err(&i2c->dev, "regmap_init() failed: %d\n", ret); 2227 return ret; 2228 } 2229 2230 mutex_init(&da7213->ctrl_lock); 2231 2232 pm_runtime_set_autosuspend_delay(&i2c->dev, 100); 2233 pm_runtime_use_autosuspend(&i2c->dev); 2234 pm_runtime_set_active(&i2c->dev); 2235 pm_runtime_enable(&i2c->dev); 2236 2237 ret = devm_snd_soc_register_component(&i2c->dev, 2238 &soc_component_dev_da7213, &da7213_dai, 1); 2239 if (ret < 0) { 2240 dev_err(&i2c->dev, "Failed to register da7213 component: %d\n", 2241 ret); 2242 } 2243 return ret; 2244 } 2245 2246 static void da7213_i2c_remove(struct i2c_client *i2c) 2247 { 2248 pm_runtime_disable(&i2c->dev); 2249 } 2250 2251 static const struct dev_pm_ops da7213_pm = { 2252 RUNTIME_PM_OPS(da7213_runtime_suspend, da7213_runtime_resume, NULL) 2253 }; 2254 2255 static const struct i2c_device_id da7213_i2c_id[] = { 2256 { .name = "da7213" }, 2257 { } 2258 }; 2259 MODULE_DEVICE_TABLE(i2c, da7213_i2c_id); 2260 2261 /* I2C codec control layer */ 2262 static struct i2c_driver da7213_i2c_driver = { 2263 .driver = { 2264 .name = "da7213", 2265 .of_match_table = of_match_ptr(da7213_of_match), 2266 .acpi_match_table = ACPI_PTR(da7213_acpi_match), 2267 .pm = pm_ptr(&da7213_pm), 2268 }, 2269 .probe = da7213_i2c_probe, 2270 .remove = da7213_i2c_remove, 2271 .id_table = da7213_i2c_id, 2272 }; 2273 2274 module_i2c_driver(da7213_i2c_driver); 2275 2276 MODULE_DESCRIPTION("ASoC DA7213 Codec driver"); 2277 MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>"); 2278 MODULE_AUTHOR("David Rau <David.Rau.opensource@dm.renesas.com>"); 2279 MODULE_LICENSE("GPL"); 2280