soc/codecs/da7219.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * da7219.c - DA7219 ALSA SoC Codec Driver
0004  *
0005  * Copyright (c) 2015 Dialog Semiconductor
0006  *
0007  * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
0008  */
0009
0010 #include <linux/acpi.h>
0011 #include <linux/clk.h>
0012 #include <linux/clkdev.h>
0013 #include <linux/clk-provider.h>
0014 #include <linux/i2c.h>
0015 #include <linux/of_device.h>
0016 #include <linux/property.h>
0017 #include <linux/regmap.h>
0018 #include <linux/slab.h>
0019 #include <linux/pm.h>
0020 #include <linux/module.h>
0021 #include <linux/delay.h>
0022 #include <linux/regulator/consumer.h>
0023 #include <sound/pcm.h>
0024 #include <sound/pcm_params.h>
0025 #include <sound/soc.h>
0026 #include <sound/soc-dapm.h>
0027 #include <sound/initval.h>
0028 #include <sound/tlv.h>
0029 #include <asm/div64.h>
0030
0031 #include <sound/da7219.h>
0032 #include "da7219.h"
0033 #include "da7219-aad.h"
0034
0035
0036 /*
0037  * TLVs and Enums
0038  */
0039
0040 /* Input TLVs */
0041 static const DECLARE_TLV_DB_SCALE(da7219_mic_gain_tlv, -600, 600, 0);
0042 static const DECLARE_TLV_DB_SCALE(da7219_mixin_gain_tlv, -450, 150, 0);
0043 static const DECLARE_TLV_DB_SCALE(da7219_adc_dig_gain_tlv, -8325, 75, 0);
0044 static const DECLARE_TLV_DB_SCALE(da7219_alc_threshold_tlv, -9450, 150, 0);
0045 static const DECLARE_TLV_DB_SCALE(da7219_alc_gain_tlv, 0, 600, 0);
0046 static const DECLARE_TLV_DB_SCALE(da7219_alc_ana_gain_tlv, 0, 600, 0);
0047 static const DECLARE_TLV_DB_SCALE(da7219_sidetone_gain_tlv, -4200, 300, 0);
0048 static const DECLARE_TLV_DB_SCALE(da7219_tonegen_gain_tlv, -4500, 300, 0);
0049
0050 /* Output TLVs */
0051 static const DECLARE_TLV_DB_SCALE(da7219_dac_eq_band_tlv, -1050, 150, 0);
0052
0053 static const DECLARE_TLV_DB_RANGE(da7219_dac_dig_gain_tlv,
0054     0x0, 0x07, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 1),
0055     /* -77.25dB to 12dB */
0056     0x08, 0x7f, TLV_DB_SCALE_ITEM(-7725, 75, 0)
0057 );
0058
0059 static const DECLARE_TLV_DB_SCALE(da7219_dac_ng_threshold_tlv, -10200, 600, 0);
0060 static const DECLARE_TLV_DB_SCALE(da7219_hp_gain_tlv, -5700, 100, 0);
0061
0062 /* Input Enums */
0063 static const char * const da7219_alc_attack_rate_txt[] = {
0064     "7.33/fs", "14.66/fs", "29.32/fs", "58.64/fs", "117.3/fs", "234.6/fs",
0065     "469.1/fs", "938.2/fs", "1876/fs", "3753/fs", "7506/fs", "15012/fs",
0066     "30024/fs"
0067 };
0068
0069 static const struct soc_enum da7219_alc_attack_rate =
0070     SOC_ENUM_SINGLE(DA7219_ALC_CTRL2, DA7219_ALC_ATTACK_SHIFT,
0071             DA7219_ALC_ATTACK_MAX, da7219_alc_attack_rate_txt);
0072
0073 static const char * const da7219_alc_release_rate_txt[] = {
0074     "28.66/fs", "57.33/fs", "114.6/fs", "229.3/fs", "458.6/fs", "917.1/fs",
0075     "1834/fs", "3668/fs", "7337/fs", "14674/fs", "29348/fs"
0076 };
0077
0078 static const struct soc_enum da7219_alc_release_rate =
0079     SOC_ENUM_SINGLE(DA7219_ALC_CTRL2, DA7219_ALC_RELEASE_SHIFT,
0080             DA7219_ALC_RELEASE_MAX, da7219_alc_release_rate_txt);
0081
0082 static const char * const da7219_alc_hold_time_txt[] = {
0083     "62/fs", "124/fs", "248/fs", "496/fs", "992/fs", "1984/fs", "3968/fs",
0084     "7936/fs", "15872/fs", "31744/fs", "63488/fs", "126976/fs",
0085     "253952/fs", "507904/fs", "1015808/fs", "2031616/fs"
0086 };
0087
0088 static const struct soc_enum da7219_alc_hold_time =
0089     SOC_ENUM_SINGLE(DA7219_ALC_CTRL3, DA7219_ALC_HOLD_SHIFT,
0090             DA7219_ALC_HOLD_MAX, da7219_alc_hold_time_txt);
0091
0092 static const char * const da7219_alc_env_rate_txt[] = {
0093     "1/4", "1/16", "1/256", "1/65536"
0094 };
0095
0096 static const struct soc_enum da7219_alc_env_attack_rate =
0097     SOC_ENUM_SINGLE(DA7219_ALC_CTRL3, DA7219_ALC_INTEG_ATTACK_SHIFT,
0098             DA7219_ALC_INTEG_MAX, da7219_alc_env_rate_txt);
0099
0100 static const struct soc_enum da7219_alc_env_release_rate =
0101     SOC_ENUM_SINGLE(DA7219_ALC_CTRL3, DA7219_ALC_INTEG_RELEASE_SHIFT,
0102             DA7219_ALC_INTEG_MAX, da7219_alc_env_rate_txt);
0103
0104 static const char * const da7219_alc_anticlip_step_txt[] = {
0105     "0.034dB/fs", "0.068dB/fs", "0.136dB/fs", "0.272dB/fs"
0106 };
0107
0108 static const struct soc_enum da7219_alc_anticlip_step =
0109     SOC_ENUM_SINGLE(DA7219_ALC_ANTICLIP_CTRL,
0110             DA7219_ALC_ANTICLIP_STEP_SHIFT,
0111             DA7219_ALC_ANTICLIP_STEP_MAX,
0112             da7219_alc_anticlip_step_txt);
0113
0114 /* Input/Output Enums */
0115 static const char * const da7219_gain_ramp_rate_txt[] = {
0116     "Nominal Rate * 8", "Nominal Rate", "Nominal Rate / 8",
0117     "Nominal Rate / 16"
0118 };
0119
0120 static const struct soc_enum da7219_gain_ramp_rate =
0121     SOC_ENUM_SINGLE(DA7219_GAIN_RAMP_CTRL, DA7219_GAIN_RAMP_RATE_SHIFT,
0122             DA7219_GAIN_RAMP_RATE_MAX, da7219_gain_ramp_rate_txt);
0123
0124 static const char * const da7219_hpf_mode_txt[] = {
0125     "Disabled", "Audio", "Voice"
0126 };
0127
0128 static const unsigned int da7219_hpf_mode_val[] = {
0129     DA7219_HPF_DISABLED, DA7219_HPF_AUDIO_EN, DA7219_HPF_VOICE_EN,
0130 };
0131
0132 static const struct soc_enum da7219_adc_hpf_mode =
0133     SOC_VALUE_ENUM_SINGLE(DA7219_ADC_FILTERS1, DA7219_HPF_MODE_SHIFT,
0134                   DA7219_HPF_MODE_MASK, DA7219_HPF_MODE_MAX,
0135                   da7219_hpf_mode_txt, da7219_hpf_mode_val);
0136
0137 static const struct soc_enum da7219_dac_hpf_mode =
0138     SOC_VALUE_ENUM_SINGLE(DA7219_DAC_FILTERS1, DA7219_HPF_MODE_SHIFT,
0139                   DA7219_HPF_MODE_MASK, DA7219_HPF_MODE_MAX,
0140                   da7219_hpf_mode_txt, da7219_hpf_mode_val);
0141
0142 static const char * const da7219_audio_hpf_corner_txt[] = {
0143     "2Hz", "4Hz", "8Hz", "16Hz"
0144 };
0145
0146 static const struct soc_enum da7219_adc_audio_hpf_corner =
0147     SOC_ENUM_SINGLE(DA7219_ADC_FILTERS1,
0148             DA7219_ADC_AUDIO_HPF_CORNER_SHIFT,
0149             DA7219_AUDIO_HPF_CORNER_MAX,
0150             da7219_audio_hpf_corner_txt);
0151
0152 static const struct soc_enum da7219_dac_audio_hpf_corner =
0153     SOC_ENUM_SINGLE(DA7219_DAC_FILTERS1,
0154             DA7219_DAC_AUDIO_HPF_CORNER_SHIFT,
0155             DA7219_AUDIO_HPF_CORNER_MAX,
0156             da7219_audio_hpf_corner_txt);
0157
0158 static const char * const da7219_voice_hpf_corner_txt[] = {
0159     "2.5Hz", "25Hz", "50Hz", "100Hz", "150Hz", "200Hz", "300Hz", "400Hz"
0160 };
0161
0162 static const struct soc_enum da7219_adc_voice_hpf_corner =
0163     SOC_ENUM_SINGLE(DA7219_ADC_FILTERS1,
0164             DA7219_ADC_VOICE_HPF_CORNER_SHIFT,
0165             DA7219_VOICE_HPF_CORNER_MAX,
0166             da7219_voice_hpf_corner_txt);
0167
0168 static const struct soc_enum da7219_dac_voice_hpf_corner =
0169     SOC_ENUM_SINGLE(DA7219_DAC_FILTERS1,
0170             DA7219_DAC_VOICE_HPF_CORNER_SHIFT,
0171             DA7219_VOICE_HPF_CORNER_MAX,
0172             da7219_voice_hpf_corner_txt);
0173
0174 static const char * const da7219_tonegen_dtmf_key_txt[] = {
0175     "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D",
0176     "*", "#"
0177 };
0178
0179 static const struct soc_enum da7219_tonegen_dtmf_key =
0180     SOC_ENUM_SINGLE(DA7219_TONE_GEN_CFG1, DA7219_DTMF_REG_SHIFT,
0181             DA7219_DTMF_REG_MAX, da7219_tonegen_dtmf_key_txt);
0182
0183 static const char * const da7219_tonegen_swg_sel_txt[] = {
0184     "Sum", "SWG1", "SWG2", "SWG1_1-Cos"
0185 };
0186
0187 static const struct soc_enum da7219_tonegen_swg_sel =
0188     SOC_ENUM_SINGLE(DA7219_TONE_GEN_CFG2, DA7219_SWG_SEL_SHIFT,
0189             DA7219_SWG_SEL_MAX, da7219_tonegen_swg_sel_txt);
0190
0191 /* Output Enums */
0192 static const char * const da7219_dac_softmute_rate_txt[] = {
0193     "1 Sample", "2 Samples", "4 Samples", "8 Samples", "16 Samples",
0194     "32 Samples", "64 Samples"
0195 };
0196
0197 static const struct soc_enum da7219_dac_softmute_rate =
0198     SOC_ENUM_SINGLE(DA7219_DAC_FILTERS5, DA7219_DAC_SOFTMUTE_RATE_SHIFT,
0199             DA7219_DAC_SOFTMUTE_RATE_MAX,
0200             da7219_dac_softmute_rate_txt);
0201
0202 static const char * const da7219_dac_ng_setup_time_txt[] = {
0203     "256 Samples", "512 Samples", "1024 Samples", "2048 Samples"
0204 };
0205
0206 static const struct soc_enum da7219_dac_ng_setup_time =
0207     SOC_ENUM_SINGLE(DA7219_DAC_NG_SETUP_TIME,
0208             DA7219_DAC_NG_SETUP_TIME_SHIFT,
0209             DA7219_DAC_NG_SETUP_TIME_MAX,
0210             da7219_dac_ng_setup_time_txt);
0211
0212 static const char * const da7219_dac_ng_rampup_txt[] = {
0213     "0.22ms/dB", "0.0138ms/dB"
0214 };
0215
0216 static const struct soc_enum da7219_dac_ng_rampup_rate =
0217     SOC_ENUM_SINGLE(DA7219_DAC_NG_SETUP_TIME,
0218             DA7219_DAC_NG_RAMPUP_RATE_SHIFT,
0219             DA7219_DAC_NG_RAMP_RATE_MAX,
0220             da7219_dac_ng_rampup_txt);
0221
0222 static const char * const da7219_dac_ng_rampdown_txt[] = {
0223     "0.88ms/dB", "14.08ms/dB"
0224 };
0225
0226 static const struct soc_enum da7219_dac_ng_rampdown_rate =
0227     SOC_ENUM_SINGLE(DA7219_DAC_NG_SETUP_TIME,
0228             DA7219_DAC_NG_RAMPDN_RATE_SHIFT,
0229             DA7219_DAC_NG_RAMP_RATE_MAX,
0230             da7219_dac_ng_rampdown_txt);
0231
0232
0233 static const char * const da7219_cp_track_mode_txt[] = {
0234     "Largest Volume", "DAC Volume", "Signal Magnitude"
0235 };
0236
0237 static const unsigned int da7219_cp_track_mode_val[] = {
0238     DA7219_CP_MCHANGE_LARGEST_VOL, DA7219_CP_MCHANGE_DAC_VOL,
0239     DA7219_CP_MCHANGE_SIG_MAG
0240 };
0241
0242 static const struct soc_enum da7219_cp_track_mode =
0243     SOC_VALUE_ENUM_SINGLE(DA7219_CP_CTRL, DA7219_CP_MCHANGE_SHIFT,
0244                   DA7219_CP_MCHANGE_REL_MASK, DA7219_CP_MCHANGE_MAX,
0245                   da7219_cp_track_mode_txt,
0246                   da7219_cp_track_mode_val);
0247
0248
0249 /*
0250  * Control Functions
0251  */
0252
0253 /* Locked Kcontrol calls */
0254 static int da7219_volsw_locked_get(struct snd_kcontrol *kcontrol,
0255                    struct snd_ctl_elem_value *ucontrol)
0256 {
0257     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0258     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0259     int ret;
0260
0261     mutex_lock(&da7219->ctrl_lock);
0262     ret = snd_soc_get_volsw(kcontrol, ucontrol);
0263     mutex_unlock(&da7219->ctrl_lock);
0264
0265     return ret;
0266 }
0267
0268 static int da7219_volsw_locked_put(struct snd_kcontrol *kcontrol,
0269                    struct snd_ctl_elem_value *ucontrol)
0270 {
0271     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0272     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0273     int ret;
0274
0275     mutex_lock(&da7219->ctrl_lock);
0276     ret = snd_soc_put_volsw(kcontrol, ucontrol);
0277     mutex_unlock(&da7219->ctrl_lock);
0278
0279     return ret;
0280 }
0281
0282 static int da7219_enum_locked_get(struct snd_kcontrol *kcontrol,
0283                 struct snd_ctl_elem_value *ucontrol)
0284 {
0285     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0286     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0287     int ret;
0288
0289     mutex_lock(&da7219->ctrl_lock);
0290     ret = snd_soc_get_enum_double(kcontrol, ucontrol);
0291     mutex_unlock(&da7219->ctrl_lock);
0292
0293     return ret;
0294 }
0295
0296 static int da7219_enum_locked_put(struct snd_kcontrol *kcontrol,
0297                 struct snd_ctl_elem_value *ucontrol)
0298 {
0299     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0300     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0301     int ret;
0302
0303     mutex_lock(&da7219->ctrl_lock);
0304     ret = snd_soc_put_enum_double(kcontrol, ucontrol);
0305     mutex_unlock(&da7219->ctrl_lock);
0306
0307     return ret;
0308 }
0309
0310 /* ALC */
0311 static void da7219_alc_calib(struct snd_soc_component *component)
0312 {
0313     u8 mic_ctrl, mixin_ctrl, adc_ctrl, calib_ctrl;
0314
0315     /* Save current state of mic control register */
0316     mic_ctrl = snd_soc_component_read(component, DA7219_MIC_1_CTRL);
0317
0318     /* Save current state of input mixer control register */
0319     mixin_ctrl = snd_soc_component_read(component, DA7219_MIXIN_L_CTRL);
0320
0321     /* Save current state of input ADC control register */
0322     adc_ctrl = snd_soc_component_read(component, DA7219_ADC_L_CTRL);
0323
0324     /* Enable then Mute MIC PGAs */
0325     snd_soc_component_update_bits(component, DA7219_MIC_1_CTRL, DA7219_MIC_1_AMP_EN_MASK,
0326                 DA7219_MIC_1_AMP_EN_MASK);
0327     snd_soc_component_update_bits(component, DA7219_MIC_1_CTRL,
0328                 DA7219_MIC_1_AMP_MUTE_EN_MASK,
0329                 DA7219_MIC_1_AMP_MUTE_EN_MASK);
0330
0331     /* Enable input mixers unmuted */
0332     snd_soc_component_update_bits(component, DA7219_MIXIN_L_CTRL,
0333                 DA7219_MIXIN_L_AMP_EN_MASK |
0334                 DA7219_MIXIN_L_AMP_MUTE_EN_MASK,
0335                 DA7219_MIXIN_L_AMP_EN_MASK);
0336
0337     /* Enable input filters unmuted */
0338     snd_soc_component_update_bits(component, DA7219_ADC_L_CTRL,
0339                 DA7219_ADC_L_MUTE_EN_MASK | DA7219_ADC_L_EN_MASK,
0340                 DA7219_ADC_L_EN_MASK);
0341
0342     /* Perform auto calibration */
0343     snd_soc_component_update_bits(component, DA7219_ALC_CTRL1,
0344                 DA7219_ALC_AUTO_CALIB_EN_MASK,
0345                 DA7219_ALC_AUTO_CALIB_EN_MASK);
0346     do {
0347         calib_ctrl = snd_soc_component_read(component, DA7219_ALC_CTRL1);
0348     } while (calib_ctrl & DA7219_ALC_AUTO_CALIB_EN_MASK);
0349
0350     /* If auto calibration fails, disable DC offset, hybrid ALC */
0351     if (calib_ctrl & DA7219_ALC_CALIB_OVERFLOW_MASK) {
0352         dev_warn(component->dev,
0353              "ALC auto calibration failed with overflow\n");
0354         snd_soc_component_update_bits(component, DA7219_ALC_CTRL1,
0355                     DA7219_ALC_OFFSET_EN_MASK |
0356                     DA7219_ALC_SYNC_MODE_MASK, 0);
0357     } else {
0358         /* Enable DC offset cancellation, hybrid mode */
0359         snd_soc_component_update_bits(component, DA7219_ALC_CTRL1,
0360                     DA7219_ALC_OFFSET_EN_MASK |
0361                     DA7219_ALC_SYNC_MODE_MASK,
0362                     DA7219_ALC_OFFSET_EN_MASK |
0363                     DA7219_ALC_SYNC_MODE_MASK);
0364     }
0365
0366     /* Restore input filter control register to original state */
0367     snd_soc_component_write(component, DA7219_ADC_L_CTRL, adc_ctrl);
0368
0369     /* Restore input mixer control registers to original state */
0370     snd_soc_component_write(component, DA7219_MIXIN_L_CTRL, mixin_ctrl);
0371
0372     /* Restore MIC control registers to original states */
0373     snd_soc_component_write(component, DA7219_MIC_1_CTRL, mic_ctrl);
0374 }
0375
0376 static int da7219_mixin_gain_put(struct snd_kcontrol *kcontrol,
0377                  struct snd_ctl_elem_value *ucontrol)
0378 {
0379     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0380     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0381     int ret;
0382
0383     ret = snd_soc_put_volsw(kcontrol, ucontrol);
0384
0385     /*
0386      * If ALC in operation and value of control has been updated,
0387      * make sure calibrated offsets are updated.
0388      */
0389     if ((ret == 1) && (da7219->alc_en))
0390         da7219_alc_calib(component);
0391
0392     return ret;
0393 }
0394
0395 static int da7219_alc_sw_put(struct snd_kcontrol *kcontrol,
0396                  struct snd_ctl_elem_value *ucontrol)
0397 {
0398     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0399     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0400
0401
0402     /* Force ALC offset calibration if enabling ALC */
0403     if ((ucontrol->value.integer.value[0]) && (!da7219->alc_en)) {
0404         da7219_alc_calib(component);
0405         da7219->alc_en = true;
0406     } else {
0407         da7219->alc_en = false;
0408     }
0409
0410     return snd_soc_put_volsw(kcontrol, ucontrol);
0411 }
0412
0413 /* ToneGen */
0414 static int da7219_tonegen_freq_get(struct snd_kcontrol *kcontrol,
0415                    struct snd_ctl_elem_value *ucontrol)
0416 {
0417     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0418     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0419     struct soc_mixer_control *mixer_ctrl =
0420         (struct soc_mixer_control *) kcontrol->private_value;
0421     unsigned int reg = mixer_ctrl->reg;
0422     __le16 val;
0423     int ret;
0424
0425     mutex_lock(&da7219->ctrl_lock);
0426     ret = regmap_raw_read(da7219->regmap, reg, &val, sizeof(val));
0427     mutex_unlock(&da7219->ctrl_lock);
0428
0429     if (ret)
0430         return ret;
0431
0432     /*
0433      * Frequency value spans two 8-bit registers, lower then upper byte.
0434      * Therefore we need to convert to host endianness here.
0435      */
0436     ucontrol->value.integer.value[0] = le16_to_cpu(val);
0437
0438     return 0;
0439 }
0440
0441 static int da7219_tonegen_freq_put(struct snd_kcontrol *kcontrol,
0442                    struct snd_ctl_elem_value *ucontrol)
0443 {
0444     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0445     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0446     struct soc_mixer_control *mixer_ctrl =
0447         (struct soc_mixer_control *) kcontrol->private_value;
0448     unsigned int reg = mixer_ctrl->reg;
0449     __le16 val_new, val_old;
0450     int ret;
0451
0452     /*
0453      * Frequency value spans two 8-bit registers, lower then upper byte.
0454      * Therefore we need to convert to little endian here to align with
0455      * HW registers.
0456      */
0457     val_new = cpu_to_le16(ucontrol->value.integer.value[0]);
0458
0459     mutex_lock(&da7219->ctrl_lock);
0460     ret = regmap_raw_read(da7219->regmap, reg, &val_old, sizeof(val_old));
0461     if (ret == 0 && (val_old != val_new))
0462         ret = regmap_raw_write(da7219->regmap, reg,
0463                 &val_new, sizeof(val_new));
0464     mutex_unlock(&da7219->ctrl_lock);
0465
0466     if (ret < 0)
0467         return ret;
0468
0469     return val_old != val_new;
0470 }
0471
0472
0473 /*
0474  * KControls
0475  */
0476
0477 static const struct snd_kcontrol_new da7219_snd_controls[] = {
0478     /* Mics */
0479     SOC_SINGLE_TLV("Mic Volume", DA7219_MIC_1_GAIN,
0480                DA7219_MIC_1_AMP_GAIN_SHIFT, DA7219_MIC_1_AMP_GAIN_MAX,
0481                DA7219_NO_INVERT, da7219_mic_gain_tlv),
0482     SOC_SINGLE("Mic Switch", DA7219_MIC_1_CTRL,
0483            DA7219_MIC_1_AMP_MUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0484            DA7219_INVERT),
0485
0486     /* Mixer Input */
0487     SOC_SINGLE_EXT_TLV("Mixin Volume", DA7219_MIXIN_L_GAIN,
0488                DA7219_MIXIN_L_AMP_GAIN_SHIFT,
0489                DA7219_MIXIN_L_AMP_GAIN_MAX, DA7219_NO_INVERT,
0490                snd_soc_get_volsw, da7219_mixin_gain_put,
0491                da7219_mixin_gain_tlv),
0492     SOC_SINGLE("Mixin Switch", DA7219_MIXIN_L_CTRL,
0493            DA7219_MIXIN_L_AMP_MUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0494            DA7219_INVERT),
0495     SOC_SINGLE("Mixin Gain Ramp Switch", DA7219_MIXIN_L_CTRL,
0496            DA7219_MIXIN_L_AMP_RAMP_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0497            DA7219_NO_INVERT),
0498     SOC_SINGLE("Mixin ZC Gain Switch", DA7219_MIXIN_L_CTRL,
0499            DA7219_MIXIN_L_AMP_ZC_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0500            DA7219_NO_INVERT),
0501
0502     /* ADC */
0503     SOC_SINGLE_TLV("Capture Digital Volume", DA7219_ADC_L_GAIN,
0504                DA7219_ADC_L_DIGITAL_GAIN_SHIFT,
0505                DA7219_ADC_L_DIGITAL_GAIN_MAX, DA7219_NO_INVERT,
0506                da7219_adc_dig_gain_tlv),
0507     SOC_SINGLE("Capture Digital Switch", DA7219_ADC_L_CTRL,
0508            DA7219_ADC_L_MUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0509            DA7219_INVERT),
0510     SOC_SINGLE("Capture Digital Gain Ramp Switch", DA7219_ADC_L_CTRL,
0511            DA7219_ADC_L_RAMP_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0512            DA7219_NO_INVERT),
0513
0514     /* ALC */
0515     SOC_ENUM("ALC Attack Rate", da7219_alc_attack_rate),
0516     SOC_ENUM("ALC Release Rate", da7219_alc_release_rate),
0517     SOC_ENUM("ALC Hold Time", da7219_alc_hold_time),
0518     SOC_ENUM("ALC Envelope Attack Rate", da7219_alc_env_attack_rate),
0519     SOC_ENUM("ALC Envelope Release Rate", da7219_alc_env_release_rate),
0520     SOC_SINGLE_TLV("ALC Noise Threshold", DA7219_ALC_NOISE,
0521                DA7219_ALC_NOISE_SHIFT, DA7219_ALC_THRESHOLD_MAX,
0522                DA7219_INVERT, da7219_alc_threshold_tlv),
0523     SOC_SINGLE_TLV("ALC Min Threshold", DA7219_ALC_TARGET_MIN,
0524                DA7219_ALC_THRESHOLD_MIN_SHIFT, DA7219_ALC_THRESHOLD_MAX,
0525                DA7219_INVERT, da7219_alc_threshold_tlv),
0526     SOC_SINGLE_TLV("ALC Max Threshold", DA7219_ALC_TARGET_MAX,
0527                DA7219_ALC_THRESHOLD_MAX_SHIFT, DA7219_ALC_THRESHOLD_MAX,
0528                DA7219_INVERT, da7219_alc_threshold_tlv),
0529     SOC_SINGLE_TLV("ALC Max Attenuation", DA7219_ALC_GAIN_LIMITS,
0530                DA7219_ALC_ATTEN_MAX_SHIFT, DA7219_ALC_ATTEN_GAIN_MAX,
0531                DA7219_NO_INVERT, da7219_alc_gain_tlv),
0532     SOC_SINGLE_TLV("ALC Max Volume", DA7219_ALC_GAIN_LIMITS,
0533                DA7219_ALC_GAIN_MAX_SHIFT, DA7219_ALC_ATTEN_GAIN_MAX,
0534                DA7219_NO_INVERT, da7219_alc_gain_tlv),
0535     SOC_SINGLE_RANGE_TLV("ALC Min Analog Volume", DA7219_ALC_ANA_GAIN_LIMITS,
0536                  DA7219_ALC_ANA_GAIN_MIN_SHIFT,
0537                  DA7219_ALC_ANA_GAIN_MIN, DA7219_ALC_ANA_GAIN_MAX,
0538                  DA7219_NO_INVERT, da7219_alc_ana_gain_tlv),
0539     SOC_SINGLE_RANGE_TLV("ALC Max Analog Volume", DA7219_ALC_ANA_GAIN_LIMITS,
0540                  DA7219_ALC_ANA_GAIN_MAX_SHIFT,
0541                  DA7219_ALC_ANA_GAIN_MIN, DA7219_ALC_ANA_GAIN_MAX,
0542                  DA7219_NO_INVERT, da7219_alc_ana_gain_tlv),
0543     SOC_ENUM("ALC Anticlip Step", da7219_alc_anticlip_step),
0544     SOC_SINGLE("ALC Anticlip Switch", DA7219_ALC_ANTICLIP_CTRL,
0545            DA7219_ALC_ANTIPCLIP_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0546            DA7219_NO_INVERT),
0547     SOC_SINGLE_EXT("ALC Switch", DA7219_ALC_CTRL1, DA7219_ALC_EN_SHIFT,
0548                DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT,
0549                snd_soc_get_volsw, da7219_alc_sw_put),
0550
0551     /* Input High-Pass Filters */
0552     SOC_ENUM("ADC HPF Mode", da7219_adc_hpf_mode),
0553     SOC_ENUM("ADC HPF Corner Audio", da7219_adc_audio_hpf_corner),
0554     SOC_ENUM("ADC HPF Corner Voice", da7219_adc_voice_hpf_corner),
0555
0556     /* Sidetone Filter */
0557     SOC_SINGLE_TLV("Sidetone Volume", DA7219_SIDETONE_GAIN,
0558                DA7219_SIDETONE_GAIN_SHIFT, DA7219_SIDETONE_GAIN_MAX,
0559                DA7219_NO_INVERT, da7219_sidetone_gain_tlv),
0560     SOC_SINGLE("Sidetone Switch", DA7219_SIDETONE_CTRL,
0561            DA7219_SIDETONE_MUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0562            DA7219_INVERT),
0563
0564     /* Tone Generator */
0565     SOC_SINGLE_EXT_TLV("ToneGen Volume", DA7219_TONE_GEN_CFG2,
0566                DA7219_TONE_GEN_GAIN_SHIFT, DA7219_TONE_GEN_GAIN_MAX,
0567                DA7219_NO_INVERT, da7219_volsw_locked_get,
0568                da7219_volsw_locked_put, da7219_tonegen_gain_tlv),
0569     SOC_ENUM_EXT("ToneGen DTMF Key", da7219_tonegen_dtmf_key,
0570              da7219_enum_locked_get, da7219_enum_locked_put),
0571     SOC_SINGLE_EXT("ToneGen DTMF Switch", DA7219_TONE_GEN_CFG1,
0572                DA7219_DTMF_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0573                DA7219_NO_INVERT, da7219_volsw_locked_get,
0574                da7219_volsw_locked_put),
0575     SOC_ENUM_EXT("ToneGen Sinewave Gen Type", da7219_tonegen_swg_sel,
0576              da7219_enum_locked_get, da7219_enum_locked_put),
0577     SOC_SINGLE_EXT("ToneGen Sinewave1 Freq", DA7219_TONE_GEN_FREQ1_L,
0578                DA7219_FREQ1_L_SHIFT, DA7219_FREQ_MAX, DA7219_NO_INVERT,
0579                da7219_tonegen_freq_get, da7219_tonegen_freq_put),
0580     SOC_SINGLE_EXT("ToneGen Sinewave2 Freq", DA7219_TONE_GEN_FREQ2_L,
0581                DA7219_FREQ2_L_SHIFT, DA7219_FREQ_MAX, DA7219_NO_INVERT,
0582                da7219_tonegen_freq_get, da7219_tonegen_freq_put),
0583     SOC_SINGLE_EXT("ToneGen On Time", DA7219_TONE_GEN_ON_PER,
0584                DA7219_BEEP_ON_PER_SHIFT, DA7219_BEEP_ON_OFF_MAX,
0585                DA7219_NO_INVERT, da7219_volsw_locked_get,
0586                da7219_volsw_locked_put),
0587     SOC_SINGLE("ToneGen Off Time", DA7219_TONE_GEN_OFF_PER,
0588            DA7219_BEEP_OFF_PER_SHIFT, DA7219_BEEP_ON_OFF_MAX,
0589            DA7219_NO_INVERT),
0590
0591     /* Gain ramping */
0592     SOC_ENUM("Gain Ramp Rate", da7219_gain_ramp_rate),
0593
0594     /* DAC High-Pass Filter */
0595     SOC_ENUM_EXT("DAC HPF Mode", da7219_dac_hpf_mode,
0596              da7219_enum_locked_get, da7219_enum_locked_put),
0597     SOC_ENUM("DAC HPF Corner Audio", da7219_dac_audio_hpf_corner),
0598     SOC_ENUM("DAC HPF Corner Voice", da7219_dac_voice_hpf_corner),
0599
0600     /* DAC 5-Band Equaliser */
0601     SOC_SINGLE_TLV("DAC EQ Band1 Volume", DA7219_DAC_FILTERS2,
0602                DA7219_DAC_EQ_BAND1_SHIFT, DA7219_DAC_EQ_BAND_MAX,
0603                DA7219_NO_INVERT, da7219_dac_eq_band_tlv),
0604     SOC_SINGLE_TLV("DAC EQ Band2 Volume", DA7219_DAC_FILTERS2,
0605                DA7219_DAC_EQ_BAND2_SHIFT, DA7219_DAC_EQ_BAND_MAX,
0606                DA7219_NO_INVERT, da7219_dac_eq_band_tlv),
0607     SOC_SINGLE_TLV("DAC EQ Band3 Volume", DA7219_DAC_FILTERS3,
0608                DA7219_DAC_EQ_BAND3_SHIFT, DA7219_DAC_EQ_BAND_MAX,
0609                DA7219_NO_INVERT, da7219_dac_eq_band_tlv),
0610     SOC_SINGLE_TLV("DAC EQ Band4 Volume", DA7219_DAC_FILTERS3,
0611                DA7219_DAC_EQ_BAND4_SHIFT, DA7219_DAC_EQ_BAND_MAX,
0612                DA7219_NO_INVERT, da7219_dac_eq_band_tlv),
0613     SOC_SINGLE_TLV("DAC EQ Band5 Volume", DA7219_DAC_FILTERS4,
0614                DA7219_DAC_EQ_BAND5_SHIFT, DA7219_DAC_EQ_BAND_MAX,
0615                DA7219_NO_INVERT, da7219_dac_eq_band_tlv),
0616     SOC_SINGLE_EXT("DAC EQ Switch", DA7219_DAC_FILTERS4,
0617                DA7219_DAC_EQ_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0618                DA7219_NO_INVERT, da7219_volsw_locked_get,
0619                da7219_volsw_locked_put),
0620
0621     /* DAC Softmute */
0622     SOC_ENUM("DAC Soft Mute Rate", da7219_dac_softmute_rate),
0623     SOC_SINGLE_EXT("DAC Soft Mute Switch", DA7219_DAC_FILTERS5,
0624                DA7219_DAC_SOFTMUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0625                DA7219_NO_INVERT, da7219_volsw_locked_get,
0626                da7219_volsw_locked_put),
0627
0628     /* DAC Noise Gate */
0629     SOC_ENUM("DAC NG Setup Time", da7219_dac_ng_setup_time),
0630     SOC_ENUM("DAC NG Rampup Rate", da7219_dac_ng_rampup_rate),
0631     SOC_ENUM("DAC NG Rampdown Rate", da7219_dac_ng_rampdown_rate),
0632     SOC_SINGLE_TLV("DAC NG Off Threshold", DA7219_DAC_NG_OFF_THRESH,
0633                DA7219_DAC_NG_OFF_THRESHOLD_SHIFT,
0634                DA7219_DAC_NG_THRESHOLD_MAX, DA7219_NO_INVERT,
0635                da7219_dac_ng_threshold_tlv),
0636     SOC_SINGLE_TLV("DAC NG On Threshold", DA7219_DAC_NG_ON_THRESH,
0637                DA7219_DAC_NG_ON_THRESHOLD_SHIFT,
0638                DA7219_DAC_NG_THRESHOLD_MAX, DA7219_NO_INVERT,
0639                da7219_dac_ng_threshold_tlv),
0640     SOC_SINGLE("DAC NG Switch", DA7219_DAC_NG_CTRL, DA7219_DAC_NG_EN_SHIFT,
0641            DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0642
0643     /* DACs */
0644     SOC_DOUBLE_R_EXT_TLV("Playback Digital Volume", DA7219_DAC_L_GAIN,
0645                  DA7219_DAC_R_GAIN, DA7219_DAC_L_DIGITAL_GAIN_SHIFT,
0646                  DA7219_DAC_DIGITAL_GAIN_MAX, DA7219_NO_INVERT,
0647                  da7219_volsw_locked_get, da7219_volsw_locked_put,
0648                  da7219_dac_dig_gain_tlv),
0649     SOC_DOUBLE_R_EXT("Playback Digital Switch", DA7219_DAC_L_CTRL,
0650              DA7219_DAC_R_CTRL, DA7219_DAC_L_MUTE_EN_SHIFT,
0651              DA7219_SWITCH_EN_MAX, DA7219_INVERT,
0652              da7219_volsw_locked_get, da7219_volsw_locked_put),
0653     SOC_DOUBLE_R("Playback Digital Gain Ramp Switch", DA7219_DAC_L_CTRL,
0654              DA7219_DAC_R_CTRL, DA7219_DAC_L_RAMP_EN_SHIFT,
0655              DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0656
0657     /* CP */
0658     SOC_ENUM("Charge Pump Track Mode", da7219_cp_track_mode),
0659     SOC_SINGLE("Charge Pump Threshold", DA7219_CP_VOL_THRESHOLD1,
0660            DA7219_CP_THRESH_VDD2_SHIFT, DA7219_CP_THRESH_VDD2_MAX,
0661            DA7219_NO_INVERT),
0662
0663     /* Headphones */
0664     SOC_DOUBLE_R_EXT_TLV("Headphone Volume", DA7219_HP_L_GAIN,
0665                  DA7219_HP_R_GAIN, DA7219_HP_L_AMP_GAIN_SHIFT,
0666                  DA7219_HP_AMP_GAIN_MAX, DA7219_NO_INVERT,
0667                  da7219_volsw_locked_get, da7219_volsw_locked_put,
0668                  da7219_hp_gain_tlv),
0669     SOC_DOUBLE_R_EXT("Headphone Switch", DA7219_HP_L_CTRL, DA7219_HP_R_CTRL,
0670              DA7219_HP_L_AMP_MUTE_EN_SHIFT, DA7219_SWITCH_EN_MAX,
0671              DA7219_INVERT, da7219_volsw_locked_get,
0672              da7219_volsw_locked_put),
0673     SOC_DOUBLE_R("Headphone Gain Ramp Switch", DA7219_HP_L_CTRL,
0674              DA7219_HP_R_CTRL, DA7219_HP_L_AMP_RAMP_EN_SHIFT,
0675              DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0676     SOC_DOUBLE_R("Headphone ZC Gain Switch", DA7219_HP_L_CTRL,
0677              DA7219_HP_R_CTRL, DA7219_HP_L_AMP_ZC_EN_SHIFT,
0678              DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0679 };
0680
0681
0682 /*
0683  * DAPM Mux Controls
0684  */
0685
0686 static const char * const da7219_out_sel_txt[] = {
0687     "ADC", "Tone Generator", "DAIL", "DAIR"
0688 };
0689
0690 static const struct soc_enum da7219_out_dail_sel =
0691     SOC_ENUM_SINGLE(DA7219_DIG_ROUTING_DAI,
0692             DA7219_DAI_L_SRC_SHIFT,
0693             DA7219_OUT_SRC_MAX,
0694             da7219_out_sel_txt);
0695
0696 static const struct snd_kcontrol_new da7219_out_dail_sel_mux =
0697     SOC_DAPM_ENUM("Out DAIL Mux", da7219_out_dail_sel);
0698
0699 static const struct soc_enum da7219_out_dair_sel =
0700     SOC_ENUM_SINGLE(DA7219_DIG_ROUTING_DAI,
0701             DA7219_DAI_R_SRC_SHIFT,
0702             DA7219_OUT_SRC_MAX,
0703             da7219_out_sel_txt);
0704
0705 static const struct snd_kcontrol_new da7219_out_dair_sel_mux =
0706     SOC_DAPM_ENUM("Out DAIR Mux", da7219_out_dair_sel);
0707
0708 static const struct soc_enum da7219_out_dacl_sel =
0709     SOC_ENUM_SINGLE(DA7219_DIG_ROUTING_DAC,
0710             DA7219_DAC_L_SRC_SHIFT,
0711             DA7219_OUT_SRC_MAX,
0712             da7219_out_sel_txt);
0713
0714 static const struct snd_kcontrol_new da7219_out_dacl_sel_mux =
0715     SOC_DAPM_ENUM("Out DACL Mux", da7219_out_dacl_sel);
0716
0717 static const struct soc_enum da7219_out_dacr_sel =
0718     SOC_ENUM_SINGLE(DA7219_DIG_ROUTING_DAC,
0719             DA7219_DAC_R_SRC_SHIFT,
0720             DA7219_OUT_SRC_MAX,
0721             da7219_out_sel_txt);
0722
0723 static const struct snd_kcontrol_new da7219_out_dacr_sel_mux =
0724     SOC_DAPM_ENUM("Out DACR Mux", da7219_out_dacr_sel);
0725
0726
0727 /*
0728  * DAPM Mixer Controls
0729  */
0730
0731 static const struct snd_kcontrol_new da7219_mixin_controls[] = {
0732     SOC_DAPM_SINGLE("Mic Switch", DA7219_MIXIN_L_SELECT,
0733             DA7219_MIXIN_L_MIX_SELECT_SHIFT,
0734             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0735 };
0736
0737 static const struct snd_kcontrol_new da7219_mixout_l_controls[] = {
0738     SOC_DAPM_SINGLE("DACL Switch", DA7219_MIXOUT_L_SELECT,
0739             DA7219_MIXOUT_L_MIX_SELECT_SHIFT,
0740             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0741 };
0742
0743 static const struct snd_kcontrol_new da7219_mixout_r_controls[] = {
0744     SOC_DAPM_SINGLE("DACR Switch", DA7219_MIXOUT_R_SELECT,
0745             DA7219_MIXOUT_R_MIX_SELECT_SHIFT,
0746             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),
0747 };
0748
0749 #define DA7219_DMIX_ST_CTRLS(reg)                   \
0750     SOC_DAPM_SINGLE("Out FilterL Switch", reg,          \
0751             DA7219_DMIX_ST_SRC_OUTFILT1L_SHIFT,     \
0752             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),    \
0753     SOC_DAPM_SINGLE("Out FilterR Switch", reg,          \
0754             DA7219_DMIX_ST_SRC_OUTFILT1R_SHIFT,     \
0755             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT),    \
0756     SOC_DAPM_SINGLE("Sidetone Switch", reg,             \
0757             DA7219_DMIX_ST_SRC_SIDETONE_SHIFT,      \
0758             DA7219_SWITCH_EN_MAX, DA7219_NO_INVERT)     \
0759
0760 static const struct snd_kcontrol_new da7219_st_out_filtl_mix_controls[] = {
0761     DA7219_DMIX_ST_CTRLS(DA7219_DROUTING_ST_OUTFILT_1L),
0762 };
0763
0764 static const struct snd_kcontrol_new da7219_st_out_filtr_mix_controls[] = {
0765     DA7219_DMIX_ST_CTRLS(DA7219_DROUTING_ST_OUTFILT_1R),
0766 };
0767
0768
0769 /*
0770  * DAPM Events
0771  */
0772
0773 static int da7219_mic_pga_event(struct snd_soc_dapm_widget *w,
0774                 struct snd_kcontrol *kcontrol, int event)
0775 {
0776     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0777     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0778
0779     switch (event) {
0780     case SND_SOC_DAPM_POST_PMU:
0781         if (da7219->micbias_on_event) {
0782             /*
0783              * Delay only for first capture after bias enabled to
0784              * avoid possible DC offset related noise.
0785              */
0786             da7219->micbias_on_event = false;
0787             msleep(da7219->mic_pga_delay);
0788         }
0789         break;
0790     default:
0791         break;
0792     }
0793
0794     return 0;
0795 }
0796
0797 static int da7219_dai_event(struct snd_soc_dapm_widget *w,
0798                 struct snd_kcontrol *kcontrol, int event)
0799 {
0800     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0801     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0802     struct clk *bclk = da7219->dai_clks[DA7219_DAI_BCLK_IDX];
0803     u8 pll_ctrl, pll_status;
0804     int i = 0, ret;
0805     bool srm_lock = false;
0806
0807     switch (event) {
0808     case SND_SOC_DAPM_PRE_PMU:
0809         if (da7219->master) {
0810             /* Enable DAI clks for master mode */
0811             if (bclk) {
0812                 ret = clk_prepare_enable(bclk);
0813                 if (ret) {
0814                     dev_err(component->dev,
0815                         "Failed to enable DAI clks\n");
0816                     return ret;
0817                 }
0818             } else {
0819                 snd_soc_component_update_bits(component,
0820                                   DA7219_DAI_CLK_MODE,
0821                                   DA7219_DAI_CLK_EN_MASK,
0822                                   DA7219_DAI_CLK_EN_MASK);
0823             }
0824         }
0825
0826         /* PC synchronised to DAI */
0827         snd_soc_component_update_bits(component, DA7219_PC_COUNT,
0828                     DA7219_PC_FREERUN_MASK, 0);
0829
0830         /* Slave mode, if SRM not enabled no need for status checks */
0831         pll_ctrl = snd_soc_component_read(component, DA7219_PLL_CTRL);
0832         if ((pll_ctrl & DA7219_PLL_MODE_MASK) != DA7219_PLL_MODE_SRM)
0833             return 0;
0834
0835         /* Check SRM has locked */
0836         do {
0837             pll_status = snd_soc_component_read(component, DA7219_PLL_SRM_STS);
0838             if (pll_status & DA7219_PLL_SRM_STS_SRM_LOCK) {
0839                 srm_lock = true;
0840             } else {
0841                 ++i;
0842                 msleep(50);
0843             }
0844         } while ((i < DA7219_SRM_CHECK_RETRIES) && (!srm_lock));
0845
0846         if (!srm_lock)
0847             dev_warn(component->dev, "SRM failed to lock\n");
0848
0849         return 0;
0850     case SND_SOC_DAPM_POST_PMD:
0851         /* PC free-running */
0852         snd_soc_component_update_bits(component, DA7219_PC_COUNT,
0853                     DA7219_PC_FREERUN_MASK,
0854                     DA7219_PC_FREERUN_MASK);
0855
0856         /* Disable DAI clks if in master mode */
0857         if (da7219->master) {
0858             if (bclk)
0859                 clk_disable_unprepare(bclk);
0860             else
0861                 snd_soc_component_update_bits(component,
0862                                   DA7219_DAI_CLK_MODE,
0863                                   DA7219_DAI_CLK_EN_MASK,
0864                                   0);
0865         }
0866
0867         return 0;
0868     default:
0869         return -EINVAL;
0870     }
0871 }
0872
0873 static int da7219_settling_event(struct snd_soc_dapm_widget *w,
0874                  struct snd_kcontrol *kcontrol, int event)
0875 {
0876     switch (event) {
0877     case SND_SOC_DAPM_POST_PMU:
0878     case SND_SOC_DAPM_POST_PMD:
0879         msleep(DA7219_SETTLING_DELAY);
0880         break;
0881     default:
0882         break;
0883     }
0884
0885     return 0;
0886 }
0887
0888 static int da7219_mixout_event(struct snd_soc_dapm_widget *w,
0889                    struct snd_kcontrol *kcontrol, int event)
0890 {
0891     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0892     u8 hp_ctrl, min_gain_mask;
0893
0894     switch (w->reg) {
0895     case DA7219_MIXOUT_L_CTRL:
0896         hp_ctrl = DA7219_HP_L_CTRL;
0897         min_gain_mask = DA7219_HP_L_AMP_MIN_GAIN_EN_MASK;
0898         break;
0899     case DA7219_MIXOUT_R_CTRL:
0900         hp_ctrl = DA7219_HP_R_CTRL;
0901         min_gain_mask = DA7219_HP_R_AMP_MIN_GAIN_EN_MASK;
0902         break;
0903     default:
0904         return -EINVAL;
0905     }
0906
0907     switch (event) {
0908     case SND_SOC_DAPM_PRE_PMD:
0909         /* Enable minimum gain on HP to avoid pops */
0910         snd_soc_component_update_bits(component, hp_ctrl, min_gain_mask,
0911                     min_gain_mask);
0912
0913         msleep(DA7219_MIN_GAIN_DELAY);
0914
0915         break;
0916     case SND_SOC_DAPM_POST_PMU:
0917         /* Remove minimum gain on HP */
0918         snd_soc_component_update_bits(component, hp_ctrl, min_gain_mask, 0);
0919
0920         break;
0921     }
0922
0923     return 0;
0924 }
0925
0926 static int da7219_gain_ramp_event(struct snd_soc_dapm_widget *w,
0927                   struct snd_kcontrol *kcontrol, int event)
0928 {
0929     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0930     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
0931
0932     switch (event) {
0933     case SND_SOC_DAPM_PRE_PMU:
0934     case SND_SOC_DAPM_PRE_PMD:
0935         /* Ensure nominal gain ramping for DAPM sequence */
0936         da7219->gain_ramp_ctrl =
0937             snd_soc_component_read(component, DA7219_GAIN_RAMP_CTRL);
0938         snd_soc_component_write(component, DA7219_GAIN_RAMP_CTRL,
0939                   DA7219_GAIN_RAMP_RATE_NOMINAL);
0940         break;
0941     case SND_SOC_DAPM_POST_PMU:
0942     case SND_SOC_DAPM_POST_PMD:
0943         /* Restore previous gain ramp settings */
0944         snd_soc_component_write(component, DA7219_GAIN_RAMP_CTRL,
0945                   da7219->gain_ramp_ctrl);
0946         break;
0947     }
0948
0949     return 0;
0950 }
0951
0952
0953 /*
0954  * DAPM Widgets
0955  */
0956
0957 static const struct snd_soc_dapm_widget da7219_dapm_widgets[] = {
0958     /* Input Supplies */
0959     SND_SOC_DAPM_SUPPLY("Mic Bias", DA7219_MICBIAS_CTRL,
0960                 DA7219_MICBIAS1_EN_SHIFT, DA7219_NO_INVERT,
0961                 NULL, 0),
0962
0963     /* Inputs */
0964     SND_SOC_DAPM_INPUT("MIC"),
0965
0966     /* Input PGAs */
0967     SND_SOC_DAPM_PGA_E("Mic PGA", DA7219_MIC_1_CTRL,
0968                DA7219_MIC_1_AMP_EN_SHIFT, DA7219_NO_INVERT,
0969                NULL, 0, da7219_mic_pga_event, SND_SOC_DAPM_POST_PMU),
0970     SND_SOC_DAPM_PGA_E("Mixin PGA", DA7219_MIXIN_L_CTRL,
0971                DA7219_MIXIN_L_AMP_EN_SHIFT, DA7219_NO_INVERT,
0972                NULL, 0, da7219_settling_event, SND_SOC_DAPM_POST_PMU),
0973
0974     /* Input Filters */
0975     SND_SOC_DAPM_ADC("ADC", NULL, DA7219_ADC_L_CTRL, DA7219_ADC_L_EN_SHIFT,
0976              DA7219_NO_INVERT),
0977
0978     /* Tone Generator */
0979     SND_SOC_DAPM_SIGGEN("TONE"),
0980     SND_SOC_DAPM_PGA("Tone Generator", DA7219_TONE_GEN_CFG1,
0981              DA7219_START_STOPN_SHIFT, DA7219_NO_INVERT, NULL, 0),
0982
0983     /* Sidetone Input */
0984     SND_SOC_DAPM_ADC("Sidetone Filter", NULL, DA7219_SIDETONE_CTRL,
0985              DA7219_SIDETONE_EN_SHIFT, DA7219_NO_INVERT),
0986
0987     /* Input Mixer Supply */
0988     SND_SOC_DAPM_SUPPLY("Mixer In Supply", DA7219_MIXIN_L_CTRL,
0989                 DA7219_MIXIN_L_MIX_EN_SHIFT, DA7219_NO_INVERT,
0990                 NULL, 0),
0991
0992     /* Input Mixer */
0993     SND_SOC_DAPM_MIXER("Mixer In", SND_SOC_NOPM, 0, 0,
0994                da7219_mixin_controls,
0995                ARRAY_SIZE(da7219_mixin_controls)),
0996
0997     /* Input Muxes */
0998     SND_SOC_DAPM_MUX("Out DAIL Mux", SND_SOC_NOPM, 0, 0,
0999              &da7219_out_dail_sel_mux),
1000     SND_SOC_DAPM_MUX("Out DAIR Mux", SND_SOC_NOPM, 0, 0,
1001              &da7219_out_dair_sel_mux),
1002
1003     /* DAI Supply */
1004     SND_SOC_DAPM_SUPPLY("DAI", DA7219_DAI_CTRL, DA7219_DAI_EN_SHIFT,
1005                 DA7219_NO_INVERT, da7219_dai_event,
1006                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
1007
1008     /* DAI */
1009     SND_SOC_DAPM_AIF_OUT("DAIOUT", "Capture", 0, DA7219_DAI_TDM_CTRL,
1010                  DA7219_DAI_OE_SHIFT, DA7219_NO_INVERT),
1011     SND_SOC_DAPM_AIF_IN("DAIIN", "Playback", 0, SND_SOC_NOPM, 0, 0),
1012
1013     /* Output Muxes */
1014     SND_SOC_DAPM_MUX("Out DACL Mux", SND_SOC_NOPM, 0, 0,
1015              &da7219_out_dacl_sel_mux),
1016     SND_SOC_DAPM_MUX("Out DACR Mux", SND_SOC_NOPM, 0, 0,
1017              &da7219_out_dacr_sel_mux),
1018
1019     /* Output Mixers */
1020     SND_SOC_DAPM_MIXER("Mixer Out FilterL", SND_SOC_NOPM, 0, 0,
1021                da7219_mixout_l_controls,
1022                ARRAY_SIZE(da7219_mixout_l_controls)),
1023     SND_SOC_DAPM_MIXER("Mixer Out FilterR", SND_SOC_NOPM, 0, 0,
1024                da7219_mixout_r_controls,
1025                ARRAY_SIZE(da7219_mixout_r_controls)),
1026
1027     /* Sidetone Mixers */
1028     SND_SOC_DAPM_MIXER("ST Mixer Out FilterL", SND_SOC_NOPM, 0, 0,
1029                da7219_st_out_filtl_mix_controls,
1030                ARRAY_SIZE(da7219_st_out_filtl_mix_controls)),
1031     SND_SOC_DAPM_MIXER("ST Mixer Out FilterR", SND_SOC_NOPM, 0,
1032                0, da7219_st_out_filtr_mix_controls,
1033                ARRAY_SIZE(da7219_st_out_filtr_mix_controls)),
1034
1035     /* DACs */
1036     SND_SOC_DAPM_DAC_E("DACL", NULL, DA7219_DAC_L_CTRL,
1037                DA7219_DAC_L_EN_SHIFT, DA7219_NO_INVERT,
1038                da7219_settling_event,
1039                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1040     SND_SOC_DAPM_DAC_E("DACR", NULL, DA7219_DAC_R_CTRL,
1041                DA7219_DAC_R_EN_SHIFT, DA7219_NO_INVERT,
1042                da7219_settling_event,
1043                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1044
1045     /* Output PGAs */
1046     SND_SOC_DAPM_PGA_E("Mixout Left PGA", DA7219_MIXOUT_L_CTRL,
1047                DA7219_MIXOUT_L_AMP_EN_SHIFT, DA7219_NO_INVERT,
1048                NULL, 0, da7219_mixout_event,
1049                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1050     SND_SOC_DAPM_PGA_E("Mixout Right PGA", DA7219_MIXOUT_R_CTRL,
1051                DA7219_MIXOUT_R_AMP_EN_SHIFT, DA7219_NO_INVERT,
1052                NULL, 0, da7219_mixout_event,
1053                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1054     SND_SOC_DAPM_SUPPLY_S("Headphone Left PGA", 1, DA7219_HP_L_CTRL,
1055                   DA7219_HP_L_AMP_EN_SHIFT, DA7219_NO_INVERT,
1056                   da7219_settling_event,
1057                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1058     SND_SOC_DAPM_SUPPLY_S("Headphone Right PGA", 1, DA7219_HP_R_CTRL,
1059                   DA7219_HP_R_AMP_EN_SHIFT, DA7219_NO_INVERT,
1060                   da7219_settling_event,
1061                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1062
1063     /* Output Supplies */
1064     SND_SOC_DAPM_SUPPLY_S("Charge Pump", 0, DA7219_CP_CTRL,
1065                   DA7219_CP_EN_SHIFT, DA7219_NO_INVERT,
1066                   da7219_settling_event,
1067                   SND_SOC_DAPM_POST_PMU),
1068
1069     /* Outputs */
1070     SND_SOC_DAPM_OUTPUT("HPL"),
1071     SND_SOC_DAPM_OUTPUT("HPR"),
1072
1073     /* Pre/Post Power */
1074     SND_SOC_DAPM_PRE("Pre Power Gain Ramp", da7219_gain_ramp_event),
1075     SND_SOC_DAPM_POST("Post Power Gain Ramp", da7219_gain_ramp_event),
1076 };
1077
1078
1079 /*
1080  * DAPM Mux Routes
1081  */
1082
1083 #define DA7219_OUT_DAI_MUX_ROUTES(name)         \
1084     {name, "ADC", "Mixer In"},          \
1085     {name, "Tone Generator", "Tone Generator"}, \
1086     {name, "DAIL", "DAIOUT"},           \
1087     {name, "DAIR", "DAIOUT"}
1088
1089 #define DA7219_OUT_DAC_MUX_ROUTES(name)         \
1090     {name, "ADC", "Mixer In"},          \
1091     {name, "Tone Generator", "Tone Generator"},     \
1092     {name, "DAIL", "DAIIN"},            \
1093     {name, "DAIR", "DAIIN"}
1094
1095 /*
1096  * DAPM Mixer Routes
1097  */
1098
1099 #define DA7219_DMIX_ST_ROUTES(name)             \
1100     {name, "Out FilterL Switch", "Mixer Out FilterL"},  \
1101     {name, "Out FilterR Switch", "Mixer Out FilterR"},  \
1102     {name, "Sidetone Switch", "Sidetone Filter"}
1103
1104
1105 /*
1106  * DAPM audio route definition
1107  */
1108
1109 static const struct snd_soc_dapm_route da7219_audio_map[] = {
1110     /* Input paths */
1111     {"MIC", NULL, "Mic Bias"},
1112     {"Mic PGA", NULL, "MIC"},
1113     {"Mixin PGA", NULL, "Mic PGA"},
1114     {"ADC", NULL, "Mixin PGA"},
1115
1116     {"Mixer In", NULL, "Mixer In Supply"},
1117     {"Mixer In", "Mic Switch", "ADC"},
1118
1119     {"Sidetone Filter", NULL, "Mixer In"},
1120
1121     {"Tone Generator", NULL, "TONE"},
1122
1123     DA7219_OUT_DAI_MUX_ROUTES("Out DAIL Mux"),
1124     DA7219_OUT_DAI_MUX_ROUTES("Out DAIR Mux"),
1125
1126     {"DAIOUT", NULL, "Out DAIL Mux"},
1127     {"DAIOUT", NULL, "Out DAIR Mux"},
1128     {"DAIOUT", NULL, "DAI"},
1129
1130     /* Output paths */
1131     {"DAIIN", NULL, "DAI"},
1132
1133     DA7219_OUT_DAC_MUX_ROUTES("Out DACL Mux"),
1134     DA7219_OUT_DAC_MUX_ROUTES("Out DACR Mux"),
1135
1136     {"Mixer Out FilterL", "DACL Switch", "Out DACL Mux"},
1137     {"Mixer Out FilterR", "DACR Switch", "Out DACR Mux"},
1138
1139     DA7219_DMIX_ST_ROUTES("ST Mixer Out FilterL"),
1140     DA7219_DMIX_ST_ROUTES("ST Mixer Out FilterR"),
1141
1142     {"DACL", NULL, "ST Mixer Out FilterL"},
1143     {"DACR", NULL, "ST Mixer Out FilterR"},
1144
1145     {"Mixout Left PGA", NULL, "DACL"},
1146     {"Mixout Right PGA", NULL, "DACR"},
1147
1148     {"HPL", NULL, "Mixout Left PGA"},
1149     {"HPR", NULL, "Mixout Right PGA"},
1150
1151     {"HPL", NULL, "Headphone Left PGA"},
1152     {"HPR", NULL, "Headphone Right PGA"},
1153
1154     {"HPL", NULL, "Charge Pump"},
1155     {"HPR", NULL, "Charge Pump"},
1156 };
1157
1158
1159 /*
1160  * DAI operations
1161  */
1162
1163 static int da7219_set_dai_sysclk(struct snd_soc_dai *codec_dai,
1164                  int clk_id, unsigned int freq, int dir)
1165 {
1166     struct snd_soc_component *component = codec_dai->component;
1167     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1168     int ret = 0;
1169
1170     if ((da7219->clk_src == clk_id) && (da7219->mclk_rate == freq))
1171         return 0;
1172
1173     if ((freq < 2000000) || (freq > 54000000)) {
1174         dev_err(codec_dai->dev, "Unsupported MCLK value %d\n",
1175             freq);
1176         return -EINVAL;
1177     }
1178
1179     mutex_lock(&da7219->pll_lock);
1180
1181     switch (clk_id) {
1182     case DA7219_CLKSRC_MCLK_SQR:
1183         snd_soc_component_update_bits(component, DA7219_PLL_CTRL,
1184                     DA7219_PLL_MCLK_SQR_EN_MASK,
1185                     DA7219_PLL_MCLK_SQR_EN_MASK);
1186         break;
1187     case DA7219_CLKSRC_MCLK:
1188         snd_soc_component_update_bits(component, DA7219_PLL_CTRL,
1189                     DA7219_PLL_MCLK_SQR_EN_MASK, 0);
1190         break;
1191     default:
1192         dev_err(codec_dai->dev, "Unknown clock source %d\n", clk_id);
1193         mutex_unlock(&da7219->pll_lock);
1194         return -EINVAL;
1195     }
1196
1197     da7219->clk_src = clk_id;
1198
1199     if (da7219->mclk) {
1200         freq = clk_round_rate(da7219->mclk, freq);
1201         ret = clk_set_rate(da7219->mclk, freq);
1202         if (ret) {
1203             dev_err(codec_dai->dev, "Failed to set clock rate %d\n",
1204                 freq);
1205             mutex_unlock(&da7219->pll_lock);
1206             return ret;
1207         }
1208     }
1209
1210     da7219->mclk_rate = freq;
1211
1212     mutex_unlock(&da7219->pll_lock);
1213
1214     return 0;
1215 }
1216
1217 int da7219_set_pll(struct snd_soc_component *component, int source, unsigned int fout)
1218 {
1219     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1220
1221     u8 pll_ctrl, indiv_bits, indiv;
1222     u8 pll_frac_top, pll_frac_bot, pll_integer;
1223     u32 freq_ref;
1224     u64 frac_div;
1225
1226     /* Verify 2MHz - 54MHz MCLK provided, and set input divider */
1227     if (da7219->mclk_rate < 2000000) {
1228         dev_err(component->dev, "PLL input clock %d below valid range\n",
1229             da7219->mclk_rate);
1230         return -EINVAL;
1231     } else if (da7219->mclk_rate <= 4500000) {
1232         indiv_bits = DA7219_PLL_INDIV_2_TO_4_5_MHZ;
1233         indiv = DA7219_PLL_INDIV_2_TO_4_5_MHZ_VAL;
1234     } else if (da7219->mclk_rate <= 9000000) {
1235         indiv_bits = DA7219_PLL_INDIV_4_5_TO_9_MHZ;
1236         indiv = DA7219_PLL_INDIV_4_5_TO_9_MHZ_VAL;
1237     } else if (da7219->mclk_rate <= 18000000) {
1238         indiv_bits = DA7219_PLL_INDIV_9_TO_18_MHZ;
1239         indiv = DA7219_PLL_INDIV_9_TO_18_MHZ_VAL;
1240     } else if (da7219->mclk_rate <= 36000000) {
1241         indiv_bits = DA7219_PLL_INDIV_18_TO_36_MHZ;
1242         indiv = DA7219_PLL_INDIV_18_TO_36_MHZ_VAL;
1243     } else if (da7219->mclk_rate <= 54000000) {
1244         indiv_bits = DA7219_PLL_INDIV_36_TO_54_MHZ;
1245         indiv = DA7219_PLL_INDIV_36_TO_54_MHZ_VAL;
1246     } else {
1247         dev_err(component->dev, "PLL input clock %d above valid range\n",
1248             da7219->mclk_rate);
1249         return -EINVAL;
1250     }
1251     freq_ref = (da7219->mclk_rate / indiv);
1252     pll_ctrl = indiv_bits;
1253
1254     /* Configure PLL */
1255     switch (source) {
1256     case DA7219_SYSCLK_MCLK:
1257         pll_ctrl |= DA7219_PLL_MODE_BYPASS;
1258         snd_soc_component_update_bits(component, DA7219_PLL_CTRL,
1259                     DA7219_PLL_INDIV_MASK |
1260                     DA7219_PLL_MODE_MASK, pll_ctrl);
1261         return 0;
1262     case DA7219_SYSCLK_PLL:
1263         pll_ctrl |= DA7219_PLL_MODE_NORMAL;
1264         break;
1265     case DA7219_SYSCLK_PLL_SRM:
1266         pll_ctrl |= DA7219_PLL_MODE_SRM;
1267         break;
1268     default:
1269         dev_err(component->dev, "Invalid PLL config\n");
1270         return -EINVAL;
1271     }
1272
1273     /* Calculate dividers for PLL */
1274     pll_integer = fout / freq_ref;
1275     frac_div = (u64)(fout % freq_ref) * 8192ULL;
1276     do_div(frac_div, freq_ref);
1277     pll_frac_top = (frac_div >> DA7219_BYTE_SHIFT) & DA7219_BYTE_MASK;
1278     pll_frac_bot = (frac_div) & DA7219_BYTE_MASK;
1279
1280     /* Write PLL config & dividers */
1281     snd_soc_component_write(component, DA7219_PLL_FRAC_TOP, pll_frac_top);
1282     snd_soc_component_write(component, DA7219_PLL_FRAC_BOT, pll_frac_bot);
1283     snd_soc_component_write(component, DA7219_PLL_INTEGER, pll_integer);
1284     snd_soc_component_update_bits(component, DA7219_PLL_CTRL,
1285                 DA7219_PLL_INDIV_MASK | DA7219_PLL_MODE_MASK,
1286                 pll_ctrl);
1287
1288     return 0;
1289 }
1290
1291 static int da7219_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
1292                   int source, unsigned int fref, unsigned int fout)
1293 {
1294     struct snd_soc_component *component = codec_dai->component;
1295     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1296     int ret;
1297
1298     mutex_lock(&da7219->pll_lock);
1299     ret = da7219_set_pll(component, source, fout);
1300     mutex_unlock(&da7219->pll_lock);
1301
1302     return ret;
1303 }
1304
1305 static int da7219_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1306 {
1307     struct snd_soc_component *component = codec_dai->component;
1308     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1309     u8 dai_clk_mode = 0, dai_ctrl = 0;
1310
1311     switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1312     case SND_SOC_DAIFMT_CBM_CFM:
1313         da7219->master = true;
1314         break;
1315     case SND_SOC_DAIFMT_CBS_CFS:
1316         da7219->master = false;
1317         break;
1318     default:
1319         return -EINVAL;
1320     }
1321
1322     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1323     case SND_SOC_DAIFMT_I2S:
1324     case SND_SOC_DAIFMT_LEFT_J:
1325     case SND_SOC_DAIFMT_RIGHT_J:
1326         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1327         case SND_SOC_DAIFMT_NB_NF:
1328             break;
1329         case SND_SOC_DAIFMT_NB_IF:
1330             dai_clk_mode |= DA7219_DAI_WCLK_POL_INV;
1331             break;
1332         case SND_SOC_DAIFMT_IB_NF:
1333             dai_clk_mode |= DA7219_DAI_CLK_POL_INV;
1334             break;
1335         case SND_SOC_DAIFMT_IB_IF:
1336             dai_clk_mode |= DA7219_DAI_WCLK_POL_INV |
1337                     DA7219_DAI_CLK_POL_INV;
1338             break;
1339         default:
1340             return -EINVAL;
1341         }
1342         break;
1343     case SND_SOC_DAIFMT_DSP_B:
1344         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1345         case SND_SOC_DAIFMT_NB_NF:
1346             dai_clk_mode |= DA7219_DAI_CLK_POL_INV;
1347             break;
1348         case SND_SOC_DAIFMT_NB_IF:
1349             dai_clk_mode |= DA7219_DAI_WCLK_POL_INV |
1350                     DA7219_DAI_CLK_POL_INV;
1351             break;
1352         case SND_SOC_DAIFMT_IB_NF:
1353             break;
1354         case SND_SOC_DAIFMT_IB_IF:
1355             dai_clk_mode |= DA7219_DAI_WCLK_POL_INV;
1356             break;
1357         default:
1358             return -EINVAL;
1359         }
1360         break;
1361     default:
1362         return -EINVAL;
1363     }
1364
1365     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1366     case SND_SOC_DAIFMT_I2S:
1367         dai_ctrl |= DA7219_DAI_FORMAT_I2S;
1368         break;
1369     case SND_SOC_DAIFMT_LEFT_J:
1370         dai_ctrl |= DA7219_DAI_FORMAT_LEFT_J;
1371         break;
1372     case SND_SOC_DAIFMT_RIGHT_J:
1373         dai_ctrl |= DA7219_DAI_FORMAT_RIGHT_J;
1374         break;
1375     case SND_SOC_DAIFMT_DSP_B:
1376         dai_ctrl |= DA7219_DAI_FORMAT_DSP;
1377         break;
1378     default:
1379         return -EINVAL;
1380     }
1381
1382     snd_soc_component_update_bits(component, DA7219_DAI_CLK_MODE,
1383                 DA7219_DAI_CLK_POL_MASK | DA7219_DAI_WCLK_POL_MASK,
1384                 dai_clk_mode);
1385     snd_soc_component_update_bits(component, DA7219_DAI_CTRL, DA7219_DAI_FORMAT_MASK,
1386                 dai_ctrl);
1387
1388     return 0;
1389 }
1390
1391 static int da7219_set_bclks_per_wclk(struct snd_soc_component *component,
1392                      unsigned long factor)
1393 {
1394     u8 bclks_per_wclk;
1395
1396     switch (factor) {
1397     case 32:
1398         bclks_per_wclk = DA7219_DAI_BCLKS_PER_WCLK_32;
1399         break;
1400     case 64:
1401         bclks_per_wclk = DA7219_DAI_BCLKS_PER_WCLK_64;
1402         break;
1403     case 128:
1404         bclks_per_wclk = DA7219_DAI_BCLKS_PER_WCLK_128;
1405         break;
1406     case 256:
1407         bclks_per_wclk = DA7219_DAI_BCLKS_PER_WCLK_256;
1408         break;
1409     default:
1410         return -EINVAL;
1411     }
1412
1413     snd_soc_component_update_bits(component, DA7219_DAI_CLK_MODE,
1414                       DA7219_DAI_BCLKS_PER_WCLK_MASK,
1415                       bclks_per_wclk);
1416
1417     return 0;
1418 }
1419
1420 static int da7219_set_dai_tdm_slot(struct snd_soc_dai *dai,
1421                    unsigned int tx_mask, unsigned int rx_mask,
1422                    int slots, int slot_width)
1423 {
1424     struct snd_soc_component *component = dai->component;
1425     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1426     struct clk *wclk = da7219->dai_clks[DA7219_DAI_WCLK_IDX];
1427     struct clk *bclk = da7219->dai_clks[DA7219_DAI_BCLK_IDX];
1428     unsigned int ch_mask;
1429     unsigned long sr, bclk_rate;
1430     u8 slot_offset;
1431     u16 offset;
1432     __le16 dai_offset;
1433     u32 frame_size;
1434     int ret;
1435
1436     /* No channels enabled so disable TDM */
1437     if (!tx_mask) {
1438         snd_soc_component_update_bits(component, DA7219_DAI_TDM_CTRL,
1439                     DA7219_DAI_TDM_CH_EN_MASK |
1440                     DA7219_DAI_TDM_MODE_EN_MASK, 0);
1441         da7219->tdm_en = false;
1442         return 0;
1443     }
1444
1445     /* Check we have valid slots */
1446     slot_offset = ffs(tx_mask) - 1;
1447     ch_mask = (tx_mask >> slot_offset);
1448     if (fls(ch_mask) > DA7219_DAI_TDM_MAX_SLOTS) {
1449         dev_err(component->dev,
1450             "Invalid number of slots, max = %d\n",
1451             DA7219_DAI_TDM_MAX_SLOTS);
1452         return -EINVAL;
1453     }
1454
1455     /*
1456      * Ensure we have a valid offset into the frame, based on slot width
1457      * and slot offset of first slot we're interested in.
1458      */
1459     offset = slot_offset * slot_width;
1460     if (offset > DA7219_DAI_OFFSET_MAX) {
1461         dev_err(component->dev, "Invalid frame offset %d\n", offset);
1462         return -EINVAL;
1463     }
1464
1465     /*
1466      * If we're master, calculate & validate frame size based on slot info
1467      * provided as we have a limited set of rates available.
1468      */
1469     if (da7219->master) {
1470         frame_size = slots * slot_width;
1471
1472         if (bclk) {
1473             sr = clk_get_rate(wclk);
1474             bclk_rate = sr * frame_size;
1475             ret = clk_set_rate(bclk, bclk_rate);
1476             if (ret) {
1477                 dev_err(component->dev,
1478                     "Failed to set TDM BCLK rate %lu: %d\n",
1479                     bclk_rate, ret);
1480                 return ret;
1481             }
1482         } else {
1483             ret = da7219_set_bclks_per_wclk(component, frame_size);
1484             if (ret) {
1485                 dev_err(component->dev,
1486                     "Failed to set TDM BCLKs per WCLK %d: %d\n",
1487                     frame_size, ret);
1488                 return ret;
1489             }
1490         }
1491     }
1492
1493     dai_offset = cpu_to_le16(offset);
1494     regmap_bulk_write(da7219->regmap, DA7219_DAI_OFFSET_LOWER,
1495               &dai_offset, sizeof(dai_offset));
1496
1497     snd_soc_component_update_bits(component, DA7219_DAI_TDM_CTRL,
1498                 DA7219_DAI_TDM_CH_EN_MASK |
1499                 DA7219_DAI_TDM_MODE_EN_MASK,
1500                 (ch_mask << DA7219_DAI_TDM_CH_EN_SHIFT) |
1501                 DA7219_DAI_TDM_MODE_EN_MASK);
1502
1503     da7219->tdm_en = true;
1504
1505     return 0;
1506 }
1507
1508 static int da7219_set_sr(struct snd_soc_component *component,
1509              unsigned long rate)
1510 {
1511     u8 fs;
1512
1513     switch (rate) {
1514     case 8000:
1515         fs = DA7219_SR_8000;
1516         break;
1517     case 11025:
1518         fs = DA7219_SR_11025;
1519         break;
1520     case 12000:
1521         fs = DA7219_SR_12000;
1522         break;
1523     case 16000:
1524         fs = DA7219_SR_16000;
1525         break;
1526     case 22050:
1527         fs = DA7219_SR_22050;
1528         break;
1529     case 24000:
1530         fs = DA7219_SR_24000;
1531         break;
1532     case 32000:
1533         fs = DA7219_SR_32000;
1534         break;
1535     case 44100:
1536         fs = DA7219_SR_44100;
1537         break;
1538     case 48000:
1539         fs = DA7219_SR_48000;
1540         break;
1541     case 88200:
1542         fs = DA7219_SR_88200;
1543         break;
1544     case 96000:
1545         fs = DA7219_SR_96000;
1546         break;
1547     default:
1548         return -EINVAL;
1549     }
1550
1551     snd_soc_component_write(component, DA7219_SR, fs);
1552
1553     return 0;
1554 }
1555
1556 static int da7219_hw_params(struct snd_pcm_substream *substream,
1557                 struct snd_pcm_hw_params *params,
1558                 struct snd_soc_dai *dai)
1559 {
1560     struct snd_soc_component *component = dai->component;
1561     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1562     struct clk *wclk = da7219->dai_clks[DA7219_DAI_WCLK_IDX];
1563     struct clk *bclk = da7219->dai_clks[DA7219_DAI_BCLK_IDX];
1564     u8 dai_ctrl = 0;
1565     unsigned int channels;
1566     unsigned long sr, bclk_rate;
1567     int word_len = params_width(params);
1568     int frame_size, ret;
1569
1570     switch (word_len) {
1571     case 16:
1572         dai_ctrl |= DA7219_DAI_WORD_LENGTH_S16_LE;
1573         break;
1574     case 20:
1575         dai_ctrl |= DA7219_DAI_WORD_LENGTH_S20_LE;
1576         break;
1577     case 24:
1578         dai_ctrl |= DA7219_DAI_WORD_LENGTH_S24_LE;
1579         break;
1580     case 32:
1581         dai_ctrl |= DA7219_DAI_WORD_LENGTH_S32_LE;
1582         break;
1583     default:
1584         return -EINVAL;
1585     }
1586
1587     channels = params_channels(params);
1588     if ((channels < 1) || (channels > DA7219_DAI_CH_NUM_MAX)) {
1589         dev_err(component->dev,
1590             "Invalid number of channels, only 1 to %d supported\n",
1591             DA7219_DAI_CH_NUM_MAX);
1592         return -EINVAL;
1593     }
1594     dai_ctrl |= channels << DA7219_DAI_CH_NUM_SHIFT;
1595
1596     sr = params_rate(params);
1597     if (da7219->master && wclk) {
1598         ret = clk_set_rate(wclk, sr);
1599         if (ret) {
1600             dev_err(component->dev,
1601                 "Failed to set WCLK SR %lu: %d\n", sr, ret);
1602             return ret;
1603         }
1604     } else {
1605         ret = da7219_set_sr(component, sr);
1606         if (ret) {
1607             dev_err(component->dev,
1608                 "Failed to set SR %lu: %d\n", sr, ret);
1609             return ret;
1610         }
1611     }
1612
1613     /*
1614      * If we're master, then we have a limited set of BCLK rates we
1615      * support. For slave mode this isn't the case and the codec can detect
1616      * the BCLK rate automatically.
1617      */
1618     if (da7219->master && !da7219->tdm_en) {
1619         if ((word_len * DA7219_DAI_CH_NUM_MAX) <= 32)
1620             frame_size = 32;
1621         else
1622             frame_size = 64;
1623
1624         if (bclk) {
1625             bclk_rate = frame_size * sr;
1626             /*
1627              * Rounding the rate here avoids failure trying to set a
1628              * new rate on an already enabled bclk. In that
1629              * instance this will just set the same rate as is
1630              * currently in use, and so should continue without
1631              * problem, as long as the BCLK rate is suitable for the
1632              * desired frame size.
1633              */
1634             bclk_rate = clk_round_rate(bclk, bclk_rate);
1635             if ((bclk_rate / sr) < frame_size) {
1636                 dev_err(component->dev,
1637                     "BCLK rate mismatch against frame size");
1638                 return -EINVAL;
1639             }
1640
1641             ret = clk_set_rate(bclk, bclk_rate);
1642             if (ret) {
1643                 dev_err(component->dev,
1644                     "Failed to set BCLK rate %lu: %d\n",
1645                     bclk_rate, ret);
1646                 return ret;
1647             }
1648         } else {
1649             ret = da7219_set_bclks_per_wclk(component, frame_size);
1650             if (ret) {
1651                 dev_err(component->dev,
1652                     "Failed to set BCLKs per WCLK %d: %d\n",
1653                     frame_size, ret);
1654                 return ret;
1655             }
1656         }
1657     }
1658
1659     snd_soc_component_update_bits(component, DA7219_DAI_CTRL,
1660                 DA7219_DAI_WORD_LENGTH_MASK |
1661                 DA7219_DAI_CH_NUM_MASK,
1662                 dai_ctrl);
1663
1664     return 0;
1665 }
1666
1667 static const struct snd_soc_dai_ops da7219_dai_ops = {
1668     .hw_params  = da7219_hw_params,
1669     .set_sysclk = da7219_set_dai_sysclk,
1670     .set_pll    = da7219_set_dai_pll,
1671     .set_fmt    = da7219_set_dai_fmt,
1672     .set_tdm_slot   = da7219_set_dai_tdm_slot,
1673 };
1674
1675 #define DA7219_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1676             SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
1677
1678 #define DA7219_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
1679               SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
1680               SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
1681               SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
1682               SNDRV_PCM_RATE_96000)
1683
1684 static struct snd_soc_dai_driver da7219_dai = {
1685     .name = "da7219-hifi",
1686     .playback = {
1687         .stream_name = "Playback",
1688         .channels_min = 1,
1689         .channels_max = DA7219_DAI_CH_NUM_MAX,
1690         .rates = DA7219_RATES,
1691         .formats = DA7219_FORMATS,
1692     },
1693     .capture = {
1694         .stream_name = "Capture",
1695         .channels_min = 1,
1696         .channels_max = DA7219_DAI_CH_NUM_MAX,
1697         .rates = DA7219_RATES,
1698         .formats = DA7219_FORMATS,
1699     },
1700     .ops = &da7219_dai_ops,
1701     .symmetric_rate = 1,
1702     .symmetric_channels = 1,
1703     .symmetric_sample_bits = 1,
1704 };
1705
1706
1707 /*
1708  * DT/ACPI
1709  */
1710
1711 #ifdef CONFIG_OF
1712 static const struct of_device_id da7219_of_match[] = {
1713     { .compatible = "dlg,da7219", },
1714     { }
1715 };
1716 MODULE_DEVICE_TABLE(of, da7219_of_match);
1717 #endif
1718
1719 #ifdef CONFIG_ACPI
1720 static const struct acpi_device_id da7219_acpi_match[] = {
1721     { .id = "DLGS7219", },
1722     { }
1723 };
1724 MODULE_DEVICE_TABLE(acpi, da7219_acpi_match);
1725 #endif
1726
1727 static enum da7219_micbias_voltage
1728     da7219_fw_micbias_lvl(struct device *dev, u32 val)
1729 {
1730     switch (val) {
1731     case 1600:
1732         return DA7219_MICBIAS_1_6V;
1733     case 1800:
1734         return DA7219_MICBIAS_1_8V;
1735     case 2000:
1736         return DA7219_MICBIAS_2_0V;
1737     case 2200:
1738         return DA7219_MICBIAS_2_2V;
1739     case 2400:
1740         return DA7219_MICBIAS_2_4V;
1741     case 2600:
1742         return DA7219_MICBIAS_2_6V;
1743     default:
1744         dev_warn(dev, "Invalid micbias level");
1745         return DA7219_MICBIAS_2_2V;
1746     }
1747 }
1748
1749 static enum da7219_mic_amp_in_sel
1750     da7219_fw_mic_amp_in_sel(struct device *dev, const char *str)
1751 {
1752     if (!strcmp(str, "diff")) {
1753         return DA7219_MIC_AMP_IN_SEL_DIFF;
1754     } else if (!strcmp(str, "se_p")) {
1755         return DA7219_MIC_AMP_IN_SEL_SE_P;
1756     } else if (!strcmp(str, "se_n")) {
1757         return DA7219_MIC_AMP_IN_SEL_SE_N;
1758     } else {
1759         dev_warn(dev, "Invalid mic input type selection");
1760         return DA7219_MIC_AMP_IN_SEL_DIFF;
1761     }
1762 }
1763
1764 static struct da7219_pdata *da7219_fw_to_pdata(struct device *dev)
1765 {
1766     struct da7219_pdata *pdata;
1767     const char *of_str;
1768     u32 of_val32;
1769
1770     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1771     if (!pdata)
1772         return NULL;
1773
1774     pdata->wakeup_source = device_property_read_bool(dev, "wakeup-source");
1775
1776     pdata->dai_clk_names[DA7219_DAI_WCLK_IDX] = "da7219-dai-wclk";
1777     pdata->dai_clk_names[DA7219_DAI_BCLK_IDX] = "da7219-dai-bclk";
1778     if (device_property_read_string_array(dev, "clock-output-names",
1779                           pdata->dai_clk_names,
1780                           DA7219_DAI_NUM_CLKS) < 0)
1781         dev_warn(dev, "Using default DAI clk names: %s, %s\n",
1782              pdata->dai_clk_names[DA7219_DAI_WCLK_IDX],
1783              pdata->dai_clk_names[DA7219_DAI_BCLK_IDX]);
1784
1785     if (device_property_read_u32(dev, "dlg,micbias-lvl", &of_val32) >= 0)
1786         pdata->micbias_lvl = da7219_fw_micbias_lvl(dev, of_val32);
1787     else
1788         pdata->micbias_lvl = DA7219_MICBIAS_2_2V;
1789
1790     if (!device_property_read_string(dev, "dlg,mic-amp-in-sel", &of_str))
1791         pdata->mic_amp_in_sel = da7219_fw_mic_amp_in_sel(dev, of_str);
1792     else
1793         pdata->mic_amp_in_sel = DA7219_MIC_AMP_IN_SEL_DIFF;
1794
1795     return pdata;
1796 }
1797
1798
1799 /*
1800  * Codec driver functions
1801  */
1802
1803 static int da7219_set_bias_level(struct snd_soc_component *component,
1804                  enum snd_soc_bias_level level)
1805 {
1806     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1807     int ret;
1808
1809     switch (level) {
1810     case SND_SOC_BIAS_ON:
1811         break;
1812     case SND_SOC_BIAS_PREPARE:
1813         /* Enable MCLK for transition to ON state */
1814         if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_STANDBY) {
1815             if (da7219->mclk) {
1816                 ret = clk_prepare_enable(da7219->mclk);
1817                 if (ret) {
1818                     dev_err(component->dev,
1819                         "Failed to enable mclk\n");
1820                     return ret;
1821                 }
1822             }
1823         }
1824
1825         break;
1826     case SND_SOC_BIAS_STANDBY:
1827         if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF)
1828             /* Master bias */
1829             snd_soc_component_update_bits(component, DA7219_REFERENCES,
1830                         DA7219_BIAS_EN_MASK,
1831                         DA7219_BIAS_EN_MASK);
1832
1833         if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_PREPARE) {
1834             /* Remove MCLK */
1835             if (da7219->mclk)
1836                 clk_disable_unprepare(da7219->mclk);
1837         }
1838         break;
1839     case SND_SOC_BIAS_OFF:
1840         /* Only disable master bias if we're not a wake-up source */
1841         if (!da7219->wakeup_source)
1842             snd_soc_component_update_bits(component, DA7219_REFERENCES,
1843                         DA7219_BIAS_EN_MASK, 0);
1844
1845         break;
1846     }
1847
1848     return 0;
1849 }
1850
1851 static const char *da7219_supply_names[DA7219_NUM_SUPPLIES] = {
1852     [DA7219_SUPPLY_VDD] = "VDD",
1853     [DA7219_SUPPLY_VDDMIC] = "VDDMIC",
1854     [DA7219_SUPPLY_VDDIO] = "VDDIO",
1855 };
1856
1857 static int da7219_handle_supplies(struct snd_soc_component *component,
1858                   u8 *io_voltage_lvl)
1859 {
1860     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
1861     struct regulator *vddio;
1862     int i, ret;
1863
1864     /* Get required supplies */
1865     for (i = 0; i < DA7219_NUM_SUPPLIES; ++i)
1866         da7219->supplies[i].supply = da7219_supply_names[i];
1867
1868     ret = regulator_bulk_get(component->dev, DA7219_NUM_SUPPLIES,
1869                  da7219->supplies);
1870     if (ret) {
1871         dev_err(component->dev, "Failed to get supplies");
1872         return ret;
1873     }
1874
1875     /* Default to upper range */
1876     *io_voltage_lvl = DA7219_IO_VOLTAGE_LEVEL_2_5V_3_6V;
1877
1878     /* Determine VDDIO voltage provided */
1879     vddio = da7219->supplies[DA7219_SUPPLY_VDDIO].consumer;
1880     ret = regulator_get_voltage(vddio);
1881     if (ret < 1200000)
1882         dev_warn(component->dev, "Invalid VDDIO voltage\n");
1883     else if (ret < 2800000)
1884         *io_voltage_lvl = DA7219_IO_VOLTAGE_LEVEL_1_2V_2_8V;
1885
1886     /* Enable main supplies */
1887     ret = regulator_bulk_enable(DA7219_NUM_SUPPLIES, da7219->supplies);
1888     if (ret) {
1889         dev_err(component->dev, "Failed to enable supplies");
1890         regulator_bulk_free(DA7219_NUM_SUPPLIES, da7219->supplies);
1891         return ret;
1892     }
1893
1894     return 0;
1895 }
1896
1897 #ifdef CONFIG_COMMON_CLK
1898 static int da7219_wclk_prepare(struct clk_hw *hw)
1899 {
1900     struct da7219_priv *da7219 =
1901         container_of(hw, struct da7219_priv,
1902                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
1903     struct snd_soc_component *component = da7219->component;
1904
1905     if (!da7219->master)
1906         return -EINVAL;
1907
1908     snd_soc_component_update_bits(component, DA7219_DAI_CLK_MODE,
1909                       DA7219_DAI_CLK_EN_MASK,
1910                       DA7219_DAI_CLK_EN_MASK);
1911
1912     return 0;
1913 }
1914
1915 static void da7219_wclk_unprepare(struct clk_hw *hw)
1916 {
1917     struct da7219_priv *da7219 =
1918         container_of(hw, struct da7219_priv,
1919                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
1920     struct snd_soc_component *component = da7219->component;
1921
1922     if (!da7219->master)
1923         return;
1924
1925     snd_soc_component_update_bits(component, DA7219_DAI_CLK_MODE,
1926                       DA7219_DAI_CLK_EN_MASK, 0);
1927 }
1928
1929 static int da7219_wclk_is_prepared(struct clk_hw *hw)
1930 {
1931     struct da7219_priv *da7219 =
1932         container_of(hw, struct da7219_priv,
1933                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
1934     struct snd_soc_component *component = da7219->component;
1935     u8 clk_reg;
1936
1937     if (!da7219->master)
1938         return -EINVAL;
1939
1940     clk_reg = snd_soc_component_read(component, DA7219_DAI_CLK_MODE);
1941
1942     return !!(clk_reg & DA7219_DAI_CLK_EN_MASK);
1943 }
1944
1945 static unsigned long da7219_wclk_recalc_rate(struct clk_hw *hw,
1946                          unsigned long parent_rate)
1947 {
1948     struct da7219_priv *da7219 =
1949         container_of(hw, struct da7219_priv,
1950                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
1951     struct snd_soc_component *component = da7219->component;
1952     u8 fs = snd_soc_component_read(component, DA7219_SR);
1953
1954     switch (fs & DA7219_SR_MASK) {
1955     case DA7219_SR_8000:
1956         return 8000;
1957     case DA7219_SR_11025:
1958         return 11025;
1959     case DA7219_SR_12000:
1960         return 12000;
1961     case DA7219_SR_16000:
1962         return 16000;
1963     case DA7219_SR_22050:
1964         return 22050;
1965     case DA7219_SR_24000:
1966         return 24000;
1967     case DA7219_SR_32000:
1968         return 32000;
1969     case DA7219_SR_44100:
1970         return 44100;
1971     case DA7219_SR_48000:
1972         return 48000;
1973     case DA7219_SR_88200:
1974         return 88200;
1975     case DA7219_SR_96000:
1976         return 96000;
1977     default:
1978         return 0;
1979     }
1980 }
1981
1982 static long da7219_wclk_round_rate(struct clk_hw *hw, unsigned long rate,
1983                    unsigned long *parent_rate)
1984 {
1985     struct da7219_priv *da7219 =
1986         container_of(hw, struct da7219_priv,
1987                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
1988
1989     if (!da7219->master)
1990         return -EINVAL;
1991
1992     if (rate < 11025)
1993         return 8000;
1994     else if (rate < 12000)
1995         return 11025;
1996     else if (rate < 16000)
1997         return 12000;
1998     else if (rate < 22050)
1999         return 16000;
2000     else if (rate < 24000)
2001         return 22050;
2002     else if (rate < 32000)
2003         return 24000;
2004     else if (rate < 44100)
2005         return 32000;
2006     else if (rate < 48000)
2007         return 44100;
2008     else if (rate < 88200)
2009         return 48000;
2010     else if (rate < 96000)
2011         return 88200;
2012     else
2013         return 96000;
2014 }
2015
2016 static int da7219_wclk_set_rate(struct clk_hw *hw, unsigned long rate,
2017                 unsigned long parent_rate)
2018 {
2019     struct da7219_priv *da7219 =
2020         container_of(hw, struct da7219_priv,
2021                  dai_clks_hw[DA7219_DAI_WCLK_IDX]);
2022     struct snd_soc_component *component = da7219->component;
2023
2024     if (!da7219->master)
2025         return -EINVAL;
2026
2027     return da7219_set_sr(component, rate);
2028 }
2029
2030 static unsigned long da7219_bclk_recalc_rate(struct clk_hw *hw,
2031                          unsigned long parent_rate)
2032 {
2033     struct da7219_priv *da7219 =
2034         container_of(hw, struct da7219_priv,
2035                  dai_clks_hw[DA7219_DAI_BCLK_IDX]);
2036     struct snd_soc_component *component = da7219->component;
2037     u8 bclks_per_wclk = snd_soc_component_read(component,
2038                              DA7219_DAI_CLK_MODE);
2039
2040     switch (bclks_per_wclk & DA7219_DAI_BCLKS_PER_WCLK_MASK) {
2041     case DA7219_DAI_BCLKS_PER_WCLK_32:
2042         return parent_rate * 32;
2043     case DA7219_DAI_BCLKS_PER_WCLK_64:
2044         return parent_rate * 64;
2045     case DA7219_DAI_BCLKS_PER_WCLK_128:
2046         return parent_rate * 128;
2047     case DA7219_DAI_BCLKS_PER_WCLK_256:
2048         return parent_rate * 256;
2049     default:
2050         return 0;
2051     }
2052 }
2053
2054 static unsigned long da7219_bclk_get_factor(unsigned long rate,
2055                         unsigned long parent_rate)
2056 {
2057     unsigned long factor;
2058
2059     factor = rate / parent_rate;
2060     if (factor < 64)
2061         return 32;
2062     else if (factor < 128)
2063         return 64;
2064     else if (factor < 256)
2065         return 128;
2066     else
2067         return 256;
2068 }
2069
2070 static long da7219_bclk_round_rate(struct clk_hw *hw, unsigned long rate,
2071                    unsigned long *parent_rate)
2072 {
2073     struct da7219_priv *da7219 =
2074         container_of(hw, struct da7219_priv,
2075                  dai_clks_hw[DA7219_DAI_BCLK_IDX]);
2076     unsigned long factor;
2077
2078     if (!*parent_rate || !da7219->master)
2079         return -EINVAL;
2080
2081     /*
2082      * We don't allow changing the parent rate as some BCLK rates can be
2083      * derived from multiple parent WCLK rates (BCLK rates are set as a
2084      * multiplier of WCLK in HW). We just do some rounding down based on the
2085      * parent WCLK rate set and find the appropriate multiplier of BCLK to
2086      * get the rounded down BCLK value.
2087      */
2088     factor = da7219_bclk_get_factor(rate, *parent_rate);
2089
2090     return *parent_rate * factor;
2091 }
2092
2093 static int da7219_bclk_set_rate(struct clk_hw *hw, unsigned long rate,
2094                 unsigned long parent_rate)
2095 {
2096     struct da7219_priv *da7219 =
2097         container_of(hw, struct da7219_priv,
2098                  dai_clks_hw[DA7219_DAI_BCLK_IDX]);
2099     struct snd_soc_component *component = da7219->component;
2100     unsigned long factor;
2101
2102     if (!da7219->master)
2103         return -EINVAL;
2104
2105     factor = da7219_bclk_get_factor(rate, parent_rate);
2106
2107     return da7219_set_bclks_per_wclk(component, factor);
2108 }
2109
2110 static const struct clk_ops da7219_dai_clk_ops[DA7219_DAI_NUM_CLKS] = {
2111     [DA7219_DAI_WCLK_IDX] = {
2112         .prepare = da7219_wclk_prepare,
2113         .unprepare = da7219_wclk_unprepare,
2114         .is_prepared = da7219_wclk_is_prepared,
2115         .recalc_rate = da7219_wclk_recalc_rate,
2116         .round_rate = da7219_wclk_round_rate,
2117         .set_rate = da7219_wclk_set_rate,
2118     },
2119     [DA7219_DAI_BCLK_IDX] = {
2120         .recalc_rate = da7219_bclk_recalc_rate,
2121         .round_rate = da7219_bclk_round_rate,
2122         .set_rate = da7219_bclk_set_rate,
2123     },
2124 };
2125
2126 static int da7219_register_dai_clks(struct snd_soc_component *component)
2127 {
2128     struct device *dev = component->dev;
2129     struct device_node *np = dev->of_node;
2130     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2131     struct da7219_pdata *pdata = da7219->pdata;
2132     const char *parent_name;
2133     struct clk_hw_onecell_data *clk_data;
2134     int i, ret;
2135
2136     /* For DT platforms allocate onecell data for clock registration */
2137     if (np) {
2138         clk_data = kzalloc(struct_size(clk_data, hws, DA7219_DAI_NUM_CLKS),
2139                    GFP_KERNEL);
2140         if (!clk_data)
2141             return -ENOMEM;
2142
2143         clk_data->num = DA7219_DAI_NUM_CLKS;
2144         da7219->clk_hw_data = clk_data;
2145     }
2146
2147     for (i = 0; i < DA7219_DAI_NUM_CLKS; ++i) {
2148         struct clk_init_data init = {};
2149         struct clk_lookup *dai_clk_lookup;
2150         struct clk_hw *dai_clk_hw = &da7219->dai_clks_hw[i];
2151
2152         switch (i) {
2153         case DA7219_DAI_WCLK_IDX:
2154             /*
2155              * If we can, make MCLK the parent of WCLK to ensure
2156              * it's enabled as required.
2157              */
2158             if (da7219->mclk) {
2159                 parent_name = __clk_get_name(da7219->mclk);
2160                 init.parent_names = &parent_name;
2161                 init.num_parents = 1;
2162             } else {
2163                 init.parent_names = NULL;
2164                 init.num_parents = 0;
2165             }
2166             break;
2167         case DA7219_DAI_BCLK_IDX:
2168             /* Make WCLK the parent of BCLK */
2169             parent_name = __clk_get_name(da7219->dai_clks[DA7219_DAI_WCLK_IDX]);
2170             init.parent_names = &parent_name;
2171             init.num_parents = 1;
2172             break;
2173         default:
2174             dev_err(dev, "Invalid clock index\n");
2175             ret = -EINVAL;
2176             goto err;
2177         }
2178
2179         init.name = pdata->dai_clk_names[i];
2180         init.ops = &da7219_dai_clk_ops[i];
2181         init.flags = CLK_GET_RATE_NOCACHE | CLK_SET_RATE_GATE;
2182         dai_clk_hw->init = &init;
2183
2184         ret = clk_hw_register(dev, dai_clk_hw);
2185         if (ret) {
2186             dev_warn(dev, "Failed to register %s: %d\n", init.name,
2187                  ret);
2188             goto err;
2189         }
2190         da7219->dai_clks[i] = dai_clk_hw->clk;
2191
2192         /* For DT setup onecell data, otherwise create lookup */
2193         if (np) {
2194             da7219->clk_hw_data->hws[i] = dai_clk_hw;
2195         } else {
2196             dai_clk_lookup = clkdev_hw_create(dai_clk_hw, init.name,
2197                               "%s", dev_name(dev));
2198             if (!dai_clk_lookup) {
2199                 ret = -ENOMEM;
2200                 goto err;
2201             } else {
2202                 da7219->dai_clks_lookup[i] = dai_clk_lookup;
2203             }
2204         }
2205     }
2206
2207     /* If we're using DT, then register as provider accordingly */
2208     if (np) {
2209         ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
2210                          da7219->clk_hw_data);
2211         if (ret) {
2212             dev_err(dev, "Failed to register clock provider\n");
2213             goto err;
2214         }
2215     }
2216
2217     return 0;
2218
2219 err:
2220     do {
2221         if (da7219->dai_clks_lookup[i])
2222             clkdev_drop(da7219->dai_clks_lookup[i]);
2223
2224         clk_hw_unregister(&da7219->dai_clks_hw[i]);
2225     } while (i-- > 0);
2226
2227     if (np)
2228         kfree(da7219->clk_hw_data);
2229
2230     return ret;
2231 }
2232
2233 static void da7219_free_dai_clks(struct snd_soc_component *component)
2234 {
2235     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2236     struct device_node *np = component->dev->of_node;
2237     int i;
2238
2239     if (np)
2240         of_clk_del_provider(np);
2241
2242     for (i = DA7219_DAI_NUM_CLKS - 1; i >= 0; --i) {
2243         if (da7219->dai_clks_lookup[i])
2244             clkdev_drop(da7219->dai_clks_lookup[i]);
2245
2246         clk_hw_unregister(&da7219->dai_clks_hw[i]);
2247     }
2248
2249     if (np)
2250         kfree(da7219->clk_hw_data);
2251 }
2252 #else
2253 static inline int da7219_register_dai_clks(struct snd_soc_component *component)
2254 {
2255     return 0;
2256 }
2257
2258 static void da7219_free_dai_clks(struct snd_soc_component *component) {}
2259 #endif /* CONFIG_COMMON_CLK */
2260
2261 static void da7219_handle_pdata(struct snd_soc_component *component)
2262 {
2263     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2264     struct da7219_pdata *pdata = da7219->pdata;
2265
2266     if (pdata) {
2267         u8 micbias_lvl = 0;
2268
2269         da7219->wakeup_source = pdata->wakeup_source;
2270
2271         /* Mic Bias voltages */
2272         switch (pdata->micbias_lvl) {
2273         case DA7219_MICBIAS_1_6V:
2274         case DA7219_MICBIAS_1_8V:
2275         case DA7219_MICBIAS_2_0V:
2276         case DA7219_MICBIAS_2_2V:
2277         case DA7219_MICBIAS_2_4V:
2278         case DA7219_MICBIAS_2_6V:
2279             micbias_lvl |= (pdata->micbias_lvl <<
2280                     DA7219_MICBIAS1_LEVEL_SHIFT);
2281             break;
2282         }
2283
2284         snd_soc_component_write(component, DA7219_MICBIAS_CTRL, micbias_lvl);
2285
2286         /*
2287          * Calculate delay required to compensate for DC offset in
2288          * Mic PGA, based on Mic Bias voltage.
2289          */
2290         da7219->mic_pga_delay =  DA7219_MIC_PGA_BASE_DELAY +
2291                     (pdata->micbias_lvl *
2292                      DA7219_MIC_PGA_OFFSET_DELAY);
2293
2294         /* Mic */
2295         switch (pdata->mic_amp_in_sel) {
2296         case DA7219_MIC_AMP_IN_SEL_DIFF:
2297         case DA7219_MIC_AMP_IN_SEL_SE_P:
2298         case DA7219_MIC_AMP_IN_SEL_SE_N:
2299             snd_soc_component_write(component, DA7219_MIC_1_SELECT,
2300                       pdata->mic_amp_in_sel);
2301             break;
2302         }
2303     }
2304 }
2305
2306
2307 /*
2308  * Regmap configs
2309  */
2310
2311 static struct reg_default da7219_reg_defaults[] = {
2312     { DA7219_MIC_1_SELECT, 0x00 },
2313     { DA7219_CIF_TIMEOUT_CTRL, 0x01 },
2314     { DA7219_SR_24_48, 0x00 },
2315     { DA7219_SR, 0x0A },
2316     { DA7219_CIF_I2C_ADDR_CFG, 0x02 },
2317     { DA7219_PLL_CTRL, 0x10 },
2318     { DA7219_PLL_FRAC_TOP, 0x00 },
2319     { DA7219_PLL_FRAC_BOT, 0x00 },
2320     { DA7219_PLL_INTEGER, 0x20 },
2321     { DA7219_DIG_ROUTING_DAI, 0x10 },
2322     { DA7219_DAI_CLK_MODE, 0x01 },
2323     { DA7219_DAI_CTRL, 0x28 },
2324     { DA7219_DAI_TDM_CTRL, 0x40 },
2325     { DA7219_DIG_ROUTING_DAC, 0x32 },
2326     { DA7219_DAI_OFFSET_LOWER, 0x00 },
2327     { DA7219_DAI_OFFSET_UPPER, 0x00 },
2328     { DA7219_REFERENCES, 0x08 },
2329     { DA7219_MIXIN_L_SELECT, 0x00 },
2330     { DA7219_MIXIN_L_GAIN, 0x03 },
2331     { DA7219_ADC_L_GAIN, 0x6F },
2332     { DA7219_ADC_FILTERS1, 0x80 },
2333     { DA7219_MIC_1_GAIN, 0x01 },
2334     { DA7219_SIDETONE_CTRL, 0x40 },
2335     { DA7219_SIDETONE_GAIN, 0x0E },
2336     { DA7219_DROUTING_ST_OUTFILT_1L, 0x01 },
2337     { DA7219_DROUTING_ST_OUTFILT_1R, 0x02 },
2338     { DA7219_DAC_FILTERS5, 0x00 },
2339     { DA7219_DAC_FILTERS2, 0x88 },
2340     { DA7219_DAC_FILTERS3, 0x88 },
2341     { DA7219_DAC_FILTERS4, 0x08 },
2342     { DA7219_DAC_FILTERS1, 0x80 },
2343     { DA7219_DAC_L_GAIN, 0x6F },
2344     { DA7219_DAC_R_GAIN, 0x6F },
2345     { DA7219_CP_CTRL, 0x20 },
2346     { DA7219_HP_L_GAIN, 0x39 },
2347     { DA7219_HP_R_GAIN, 0x39 },
2348     { DA7219_MIXOUT_L_SELECT, 0x00 },
2349     { DA7219_MIXOUT_R_SELECT, 0x00 },
2350     { DA7219_MICBIAS_CTRL, 0x03 },
2351     { DA7219_MIC_1_CTRL, 0x40 },
2352     { DA7219_MIXIN_L_CTRL, 0x40 },
2353     { DA7219_ADC_L_CTRL, 0x40 },
2354     { DA7219_DAC_L_CTRL, 0x40 },
2355     { DA7219_DAC_R_CTRL, 0x40 },
2356     { DA7219_HP_L_CTRL, 0x40 },
2357     { DA7219_HP_R_CTRL, 0x40 },
2358     { DA7219_MIXOUT_L_CTRL, 0x10 },
2359     { DA7219_MIXOUT_R_CTRL, 0x10 },
2360     { DA7219_CHIP_ID1, 0x23 },
2361     { DA7219_CHIP_ID2, 0x93 },
2362     { DA7219_IO_CTRL, 0x00 },
2363     { DA7219_GAIN_RAMP_CTRL, 0x00 },
2364     { DA7219_PC_COUNT, 0x02 },
2365     { DA7219_CP_VOL_THRESHOLD1, 0x0E },
2366     { DA7219_DIG_CTRL, 0x00 },
2367     { DA7219_ALC_CTRL2, 0x00 },
2368     { DA7219_ALC_CTRL3, 0x00 },
2369     { DA7219_ALC_NOISE, 0x3F },
2370     { DA7219_ALC_TARGET_MIN, 0x3F },
2371     { DA7219_ALC_TARGET_MAX, 0x00 },
2372     { DA7219_ALC_GAIN_LIMITS, 0xFF },
2373     { DA7219_ALC_ANA_GAIN_LIMITS, 0x71 },
2374     { DA7219_ALC_ANTICLIP_CTRL, 0x00 },
2375     { DA7219_ALC_ANTICLIP_LEVEL, 0x00 },
2376     { DA7219_DAC_NG_SETUP_TIME, 0x00 },
2377     { DA7219_DAC_NG_OFF_THRESH, 0x00 },
2378     { DA7219_DAC_NG_ON_THRESH, 0x00 },
2379     { DA7219_DAC_NG_CTRL, 0x00 },
2380     { DA7219_TONE_GEN_CFG1, 0x00 },
2381     { DA7219_TONE_GEN_CFG2, 0x00 },
2382     { DA7219_TONE_GEN_CYCLES, 0x00 },
2383     { DA7219_TONE_GEN_FREQ1_L, 0x55 },
2384     { DA7219_TONE_GEN_FREQ1_U, 0x15 },
2385     { DA7219_TONE_GEN_FREQ2_L, 0x00 },
2386     { DA7219_TONE_GEN_FREQ2_U, 0x40 },
2387     { DA7219_TONE_GEN_ON_PER, 0x02 },
2388     { DA7219_TONE_GEN_OFF_PER, 0x01 },
2389     { DA7219_ACCDET_IRQ_MASK_A, 0x00 },
2390     { DA7219_ACCDET_IRQ_MASK_B, 0x00 },
2391     { DA7219_ACCDET_CONFIG_1, 0xD6 },
2392     { DA7219_ACCDET_CONFIG_2, 0x34 },
2393     { DA7219_ACCDET_CONFIG_3, 0x0A },
2394     { DA7219_ACCDET_CONFIG_4, 0x16 },
2395     { DA7219_ACCDET_CONFIG_5, 0x21 },
2396     { DA7219_ACCDET_CONFIG_6, 0x3E },
2397     { DA7219_ACCDET_CONFIG_7, 0x01 },
2398     { DA7219_SYSTEM_ACTIVE, 0x00 },
2399 };
2400
2401 static bool da7219_volatile_register(struct device *dev, unsigned int reg)
2402 {
2403     switch (reg) {
2404     case DA7219_MIC_1_GAIN_STATUS:
2405     case DA7219_MIXIN_L_GAIN_STATUS:
2406     case DA7219_ADC_L_GAIN_STATUS:
2407     case DA7219_DAC_L_GAIN_STATUS:
2408     case DA7219_DAC_R_GAIN_STATUS:
2409     case DA7219_HP_L_GAIN_STATUS:
2410     case DA7219_HP_R_GAIN_STATUS:
2411     case DA7219_CIF_CTRL:
2412     case DA7219_PLL_SRM_STS:
2413     case DA7219_ALC_CTRL1:
2414     case DA7219_SYSTEM_MODES_INPUT:
2415     case DA7219_SYSTEM_MODES_OUTPUT:
2416     case DA7219_ALC_OFFSET_AUTO_M_L:
2417     case DA7219_ALC_OFFSET_AUTO_U_L:
2418     case DA7219_TONE_GEN_CFG1:
2419     case DA7219_ACCDET_STATUS_A:
2420     case DA7219_ACCDET_STATUS_B:
2421     case DA7219_ACCDET_IRQ_EVENT_A:
2422     case DA7219_ACCDET_IRQ_EVENT_B:
2423     case DA7219_ACCDET_CONFIG_8:
2424     case DA7219_SYSTEM_STATUS:
2425         return true;
2426     default:
2427         return false;
2428     }
2429 }
2430
2431 static const struct regmap_config da7219_regmap_config = {
2432     .reg_bits = 8,
2433     .val_bits = 8,
2434
2435     .max_register = DA7219_SYSTEM_ACTIVE,
2436     .reg_defaults = da7219_reg_defaults,
2437     .num_reg_defaults = ARRAY_SIZE(da7219_reg_defaults),
2438     .volatile_reg = da7219_volatile_register,
2439     .cache_type = REGCACHE_RBTREE,
2440 };
2441
2442 static struct reg_sequence da7219_rev_aa_patch[] = {
2443     { DA7219_REFERENCES, 0x08 },
2444 };
2445
2446 static int da7219_probe(struct snd_soc_component *component)
2447 {
2448     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2449     unsigned int system_active, system_status, rev;
2450     u8 io_voltage_lvl;
2451     int i, ret;
2452
2453     da7219->component = component;
2454     mutex_init(&da7219->ctrl_lock);
2455     mutex_init(&da7219->pll_lock);
2456
2457     /* Regulator configuration */
2458     ret = da7219_handle_supplies(component, &io_voltage_lvl);
2459     if (ret)
2460         return ret;
2461
2462     regcache_cache_bypass(da7219->regmap, true);
2463
2464     /* Disable audio paths if still active from previous start */
2465     regmap_read(da7219->regmap, DA7219_SYSTEM_ACTIVE, &system_active);
2466     if (system_active) {
2467         regmap_write(da7219->regmap, DA7219_GAIN_RAMP_CTRL,
2468                  DA7219_GAIN_RAMP_RATE_NOMINAL);
2469         regmap_write(da7219->regmap, DA7219_SYSTEM_MODES_INPUT, 0x00);
2470         regmap_write(da7219->regmap, DA7219_SYSTEM_MODES_OUTPUT, 0x01);
2471
2472         for (i = 0; i < DA7219_SYS_STAT_CHECK_RETRIES; ++i) {
2473             regmap_read(da7219->regmap, DA7219_SYSTEM_STATUS,
2474                     &system_status);
2475             if (!system_status)
2476                 break;
2477
2478             msleep(DA7219_SYS_STAT_CHECK_DELAY);
2479         }
2480     }
2481
2482     /* Soft reset component */
2483     regmap_write_bits(da7219->regmap, DA7219_ACCDET_CONFIG_1,
2484               DA7219_ACCDET_EN_MASK, 0);
2485     regmap_write_bits(da7219->regmap, DA7219_CIF_CTRL,
2486               DA7219_CIF_REG_SOFT_RESET_MASK,
2487               DA7219_CIF_REG_SOFT_RESET_MASK);
2488     regmap_write_bits(da7219->regmap, DA7219_SYSTEM_ACTIVE,
2489               DA7219_SYSTEM_ACTIVE_MASK, 0);
2490     regmap_write_bits(da7219->regmap, DA7219_SYSTEM_ACTIVE,
2491               DA7219_SYSTEM_ACTIVE_MASK, 1);
2492
2493     regcache_cache_bypass(da7219->regmap, false);
2494     regmap_reinit_cache(da7219->regmap, &da7219_regmap_config);
2495
2496     /* Update IO voltage level range based on supply level */
2497     snd_soc_component_write(component, DA7219_IO_CTRL, io_voltage_lvl);
2498
2499     ret = regmap_read(da7219->regmap, DA7219_CHIP_REVISION, &rev);
2500     if (ret) {
2501         dev_err(component->dev, "Failed to read chip revision: %d\n", ret);
2502         goto err_disable_reg;
2503     }
2504
2505     switch (rev & DA7219_CHIP_MINOR_MASK) {
2506     case 0:
2507         ret = regmap_register_patch(da7219->regmap, da7219_rev_aa_patch,
2508                         ARRAY_SIZE(da7219_rev_aa_patch));
2509         if (ret) {
2510             dev_err(component->dev, "Failed to register AA patch: %d\n",
2511                 ret);
2512             goto err_disable_reg;
2513         }
2514         break;
2515     default:
2516         break;
2517     }
2518
2519     /* Handle DT/ACPI/Platform data */
2520     da7219_handle_pdata(component);
2521
2522     /* Check if MCLK provided */
2523     da7219->mclk = clk_get(component->dev, "mclk");
2524     if (IS_ERR(da7219->mclk)) {
2525         if (PTR_ERR(da7219->mclk) != -ENOENT) {
2526             ret = PTR_ERR(da7219->mclk);
2527             goto err_disable_reg;
2528         } else {
2529             da7219->mclk = NULL;
2530         }
2531     }
2532
2533     /* Register CCF DAI clock control */
2534     ret = da7219_register_dai_clks(component);
2535     if (ret)
2536         goto err_put_clk;
2537
2538     /* Default PC counter to free-running */
2539     snd_soc_component_update_bits(component, DA7219_PC_COUNT, DA7219_PC_FREERUN_MASK,
2540                 DA7219_PC_FREERUN_MASK);
2541
2542     /* Default gain ramping */
2543     snd_soc_component_update_bits(component, DA7219_MIXIN_L_CTRL,
2544                 DA7219_MIXIN_L_AMP_RAMP_EN_MASK,
2545                 DA7219_MIXIN_L_AMP_RAMP_EN_MASK);
2546     snd_soc_component_update_bits(component, DA7219_ADC_L_CTRL, DA7219_ADC_L_RAMP_EN_MASK,
2547                 DA7219_ADC_L_RAMP_EN_MASK);
2548     snd_soc_component_update_bits(component, DA7219_DAC_L_CTRL, DA7219_DAC_L_RAMP_EN_MASK,
2549                 DA7219_DAC_L_RAMP_EN_MASK);
2550     snd_soc_component_update_bits(component, DA7219_DAC_R_CTRL, DA7219_DAC_R_RAMP_EN_MASK,
2551                 DA7219_DAC_R_RAMP_EN_MASK);
2552     snd_soc_component_update_bits(component, DA7219_HP_L_CTRL,
2553                 DA7219_HP_L_AMP_RAMP_EN_MASK,
2554                 DA7219_HP_L_AMP_RAMP_EN_MASK);
2555     snd_soc_component_update_bits(component, DA7219_HP_R_CTRL,
2556                 DA7219_HP_R_AMP_RAMP_EN_MASK,
2557                 DA7219_HP_R_AMP_RAMP_EN_MASK);
2558
2559     /* Default minimum gain on HP to avoid pops during DAPM sequencing */
2560     snd_soc_component_update_bits(component, DA7219_HP_L_CTRL,
2561                 DA7219_HP_L_AMP_MIN_GAIN_EN_MASK,
2562                 DA7219_HP_L_AMP_MIN_GAIN_EN_MASK);
2563     snd_soc_component_update_bits(component, DA7219_HP_R_CTRL,
2564                 DA7219_HP_R_AMP_MIN_GAIN_EN_MASK,
2565                 DA7219_HP_R_AMP_MIN_GAIN_EN_MASK);
2566
2567     /* Default infinite tone gen, start/stop by Kcontrol */
2568     snd_soc_component_write(component, DA7219_TONE_GEN_CYCLES, DA7219_BEEP_CYCLES_MASK);
2569
2570     /* Initialise AAD block */
2571     ret = da7219_aad_init(component);
2572     if (ret)
2573         goto err_free_dai_clks;
2574
2575     return 0;
2576
2577 err_free_dai_clks:
2578     da7219_free_dai_clks(component);
2579
2580 err_put_clk:
2581     clk_put(da7219->mclk);
2582
2583 err_disable_reg:
2584     regulator_bulk_disable(DA7219_NUM_SUPPLIES, da7219->supplies);
2585     regulator_bulk_free(DA7219_NUM_SUPPLIES, da7219->supplies);
2586
2587     return ret;
2588 }
2589
2590 static void da7219_remove(struct snd_soc_component *component)
2591 {
2592     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2593
2594     da7219_aad_exit(component);
2595
2596     da7219_free_dai_clks(component);
2597     clk_put(da7219->mclk);
2598
2599     /* Supplies */
2600     regulator_bulk_disable(DA7219_NUM_SUPPLIES, da7219->supplies);
2601     regulator_bulk_free(DA7219_NUM_SUPPLIES, da7219->supplies);
2602 }
2603
2604 #ifdef CONFIG_PM
2605 static int da7219_suspend(struct snd_soc_component *component)
2606 {
2607     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2608
2609     /* Suspend AAD if we're not a wake-up source */
2610     if (!da7219->wakeup_source)
2611         da7219_aad_suspend(component);
2612
2613     snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);
2614
2615     return 0;
2616 }
2617
2618 static int da7219_resume(struct snd_soc_component *component)
2619 {
2620     struct da7219_priv *da7219 = snd_soc_component_get_drvdata(component);
2621
2622     snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);
2623
2624     /* Resume AAD if previously suspended */
2625     if (!da7219->wakeup_source)
2626         da7219_aad_resume(component);
2627
2628     return 0;
2629 }
2630 #else
2631 #define da7219_suspend NULL
2632 #define da7219_resume NULL
2633 #endif
2634
2635 static const struct snd_soc_component_driver soc_component_dev_da7219 = {
2636     .probe          = da7219_probe,
2637     .remove         = da7219_remove,
2638     .suspend        = da7219_suspend,
2639     .resume         = da7219_resume,
2640     .set_bias_level     = da7219_set_bias_level,
2641     .controls       = da7219_snd_controls,
2642     .num_controls       = ARRAY_SIZE(da7219_snd_controls),
2643     .dapm_widgets       = da7219_dapm_widgets,
2644     .num_dapm_widgets   = ARRAY_SIZE(da7219_dapm_widgets),
2645     .dapm_routes        = da7219_audio_map,
2646     .num_dapm_routes    = ARRAY_SIZE(da7219_audio_map),
2647     .idle_bias_on       = 1,
2648     .use_pmdown_time    = 1,
2649     .endianness     = 1,
2650 };
2651
2652
2653 /*
2654  * I2C layer
2655  */
2656
2657 static int da7219_i2c_probe(struct i2c_client *i2c)
2658 {
2659     struct device *dev = &i2c->dev;
2660     struct da7219_priv *da7219;
2661     int ret;
2662
2663     da7219 = devm_kzalloc(dev, sizeof(struct da7219_priv),
2664                   GFP_KERNEL);
2665     if (!da7219)
2666         return -ENOMEM;
2667
2668     i2c_set_clientdata(i2c, da7219);
2669
2670     da7219->regmap = devm_regmap_init_i2c(i2c, &da7219_regmap_config);
2671     if (IS_ERR(da7219->regmap)) {
2672         ret = PTR_ERR(da7219->regmap);
2673         dev_err(dev, "regmap_init() failed: %d\n", ret);
2674         return ret;
2675     }
2676
2677     /* Retrieve DT/ACPI/Platform data */
2678     da7219->pdata = dev_get_platdata(dev);
2679     if (!da7219->pdata)
2680         da7219->pdata = da7219_fw_to_pdata(dev);
2681
2682     /* AAD */
2683     ret = da7219_aad_probe(i2c);
2684     if (ret)
2685         return ret;
2686
2687     ret = devm_snd_soc_register_component(dev, &soc_component_dev_da7219,
2688                           &da7219_dai, 1);
2689     if (ret < 0) {
2690         dev_err(dev, "Failed to register da7219 component: %d\n", ret);
2691     }
2692     return ret;
2693 }
2694
2695 static const struct i2c_device_id da7219_i2c_id[] = {
2696     { "da7219", },
2697     { }
2698 };
2699 MODULE_DEVICE_TABLE(i2c, da7219_i2c_id);
2700
2701 static struct i2c_driver da7219_i2c_driver = {
2702     .driver = {
2703         .name = "da7219",
2704         .of_match_table = of_match_ptr(da7219_of_match),
2705         .acpi_match_table = ACPI_PTR(da7219_acpi_match),
2706     },
2707     .probe_new  = da7219_i2c_probe,
2708     .id_table   = da7219_i2c_id,
2709 };
2710
2711 module_i2c_driver(da7219_i2c_driver);
2712
2713 MODULE_DESCRIPTION("ASoC DA7219 Codec Driver");
2714 MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
2715 MODULE_LICENSE("GPL");