Lines Matching +full:main +full:- +full:micbias +full:- +full:supply
1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
20 #include <sound/soc-dapm.h>
24 #include "wcd-clsh-v2.h"
25 #include "wcd-mbhc-v2.h"
186 "vdd-rxtx", "vdd-io", "vdd-buck", "vdd-mic-bias",
189 static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(ear_pa_gain, 600, -1800);
190 static const DECLARE_TLV_DB_SCALE(line_gain, -3000, 150, 0);
346 struct regmap *rm = wcd938x->regmap;
405 port_num = ch_info->port_num;
406 ch_mask = ch_info->ch_mask;
408 port_config->num = port_num;
411 port_config->ch_mask |= ch_mask;
413 port_config->ch_mask &= ~ch_mask;
420 return wcd938x_sdw_connect_port(&wcd->ch_info[ch_id],
421 &wcd->port_config[port_num - 1],
429 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
468 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
487 if (wcd938x->comp1_enable) {
492 if (!wcd938x->comp2_enable || (snd_soc_component_read(component,
522 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
541 if (wcd938x->comp2_enable) {
546 if (!wcd938x->comp1_enable ||
576 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
581 wcd938x->ear_rx_path =
584 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
604 if (wcd938x->comp1_enable)
611 if (wcd938x->flyback_cur_det_disable == 0)
614 wcd938x->flyback_cur_det_disable++;
615 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
618 wcd938x->hph_mode);
621 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
635 if (wcd938x->comp1_enable)
655 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
669 if (wcd938x->flyback_cur_det_disable == 0)
672 wcd938x->flyback_cur_det_disable++;
673 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
676 wcd938x->hph_mode);
691 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
693 int hph_mode = wcd938x->hph_mode;
697 if (wcd938x->ldoh)
700 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
702 wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);
712 wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
715 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
726 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
727 if (!wcd938x->comp2_enable)
737 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
746 enable_irq(wcd938x->hphr_pdm_wd_int);
749 disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
755 if (!wcd938x->comp2_enable)
761 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
763 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
771 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
772 if (!wcd938x->comp2_enable)
776 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
778 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
784 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
786 if (wcd938x->ldoh)
798 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
800 int hph_mode = wcd938x->hph_mode;
804 if (wcd938x->ldoh)
807 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
809 wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);
818 wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
821 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
832 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
833 if (!wcd938x->comp1_enable)
842 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
852 enable_irq(wcd938x->hphl_pdm_wd_int);
855 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
861 if (!wcd938x->comp1_enable)
867 wcd_mbhc_event_notify(wcd938x->wcd_mbhc, WCD_EVENT_PRE_HPHL_PA_OFF);
868 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
876 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
877 if (!wcd938x->comp1_enable)
881 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
883 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
889 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
891 if (wcd938x->ldoh)
903 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
905 int hph_mode = wcd938x->hph_mode;
920 enable_irq(wcd938x->aux_pdm_wd_int);
923 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
930 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
935 wcd938x->flyback_cur_det_disable--;
936 if (wcd938x->flyback_cur_det_disable == 0)
947 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
949 int hph_mode = wcd938x->hph_mode;
957 wcd938x->ear_rx_path = snd_soc_component_read(component,
959 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
966 if (!wcd938x->comp1_enable)
980 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
981 enable_irq(wcd938x->aux_pdm_wd_int);
983 enable_irq(wcd938x->hphl_pdm_wd_int);
986 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
987 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
989 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
992 if (!wcd938x->comp1_enable)
997 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
1004 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
1007 wcd938x->flyback_cur_det_disable--;
1008 if (wcd938x->flyback_cur_det_disable == 0)
1021 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1025 switch (w->shift) {
1055 dev_err(component->dev, "%s: Invalid DMIC Selection\n",
1057 return -EINVAL;
1092 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1097 bank = (wcd938x_swr_get_current_bank(wcd938x->sdw_priv[AIF1_CAP]->sdev)) ? 0 : 1;
1102 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1105 if (test_bit(WCD_ADC1, &wcd938x->status_mask))
1106 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC1]];
1107 if (test_bit(WCD_ADC2, &wcd938x->status_mask))
1108 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC2]];
1109 if (test_bit(WCD_ADC3, &wcd938x->status_mask))
1110 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC3]];
1111 if (test_bit(WCD_ADC4, &wcd938x->status_mask))
1112 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC4]];
1129 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1167 ret = -EINVAL;
1176 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1187 set_bit(w->shift, &wcd938x->status_mask);
1192 clear_bit(w->shift, &wcd938x->status_mask);
1231 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1243 wcd938x_tx_channel_config(component, w->shift, 1);
1244 mode = wcd938x_get_adc_mode(wcd938x->tx_mode[w->shift]);
1246 dev_info(component->dev, "Invalid ADC mode\n");
1247 return -EINVAL;
1249 switch (w->shift) {
1286 wcd938x_tx_channel_config(component, w->shift, 0);
1289 switch (w->shift) {
1338 int micb_index = micb_num - 1;
1355 dev_err(component->dev, "%s: Invalid micbias number: %d\n",
1357 return -EINVAL;
1362 wcd938x->pullup_ref[micb_index]++;
1363 if ((wcd938x->pullup_ref[micb_index] == 1) &&
1364 (wcd938x->micb_ref[micb_index] == 0))
1370 if (wcd938x->pullup_ref[micb_index] > 0)
1371 wcd938x->pullup_ref[micb_index]--;
1373 if ((wcd938x->pullup_ref[micb_index] == 0) &&
1374 (wcd938x->micb_ref[micb_index] == 0))
1379 wcd938x->micb_ref[micb_index]++;
1380 if (wcd938x->micb_ref[micb_index] == 1) {
1395 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1399 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1405 if (wcd938x->micb_ref[micb_index] > 0)
1406 wcd938x->micb_ref[micb_index]--;
1408 if ((wcd938x->micb_ref[micb_index] == 0) &&
1409 (wcd938x->pullup_ref[micb_index] > 0))
1413 else if ((wcd938x->micb_ref[micb_index] == 0) &&
1414 (wcd938x->pullup_ref[micb_index] == 0)) {
1416 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1422 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1426 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1438 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1439 int micb_num = w->shift;
1461 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1462 int micb_num = w->shift;
1487 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1488 int path = e->shift_l;
1490 ucontrol->value.enumerated.item[0] = wcd938x->tx_mode[path];
1500 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1501 int path = e->shift_l;
1503 if (wcd938x->tx_mode[path] == ucontrol->value.enumerated.item[0])
1506 wcd938x->tx_mode[path] = ucontrol->value.enumerated.item[0];
1517 ucontrol->value.enumerated.item[0] = wcd938x->hph_mode;
1528 if (wcd938x->hph_mode == ucontrol->value.enumerated.item[0])
1531 wcd938x->hph_mode = ucontrol->value.enumerated.item[0];
1542 if (wcd938x->comp1_enable) {
1543 dev_err(component->dev, "Can not set EAR PA Gain, compander1 is enabled\n");
1544 return -EINVAL;
1549 ucontrol->value.integer.value[0]);
1563 mc = (struct soc_mixer_control *)(kcontrol->private_value);
1564 hphr = mc->shift;
1567 ucontrol->value.integer.value[0] = wcd938x->comp2_enable;
1569 ucontrol->value.integer.value[0] = wcd938x->comp1_enable;
1580 int value = ucontrol->value.integer.value[0];
1585 mc = (struct soc_mixer_control *)(kcontrol->private_value);
1586 hphr = mc->shift;
1588 wcd = wcd938x->sdw_priv[AIF1_PB];
1591 wcd938x->comp2_enable = value;
1593 wcd938x->comp1_enable = value;
1595 portidx = wcd->ch_info[mc->reg].port_num;
1598 wcd938x_connect_port(wcd, portidx, mc->reg, true);
1600 wcd938x_connect_port(wcd, portidx, mc->reg, false);
1611 ucontrol->value.integer.value[0] = wcd938x->ldoh;
1622 if (wcd938x->ldoh == ucontrol->value.integer.value[0])
1625 wcd938x->ldoh = ucontrol->value.integer.value[0];
1852 struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1853 int dai_id = mixer->shift;
1854 int portidx, ch_idx = mixer->reg;
1857 wcd = wcd938x->sdw_priv[dai_id];
1858 portidx = wcd->ch_info[ch_idx].port_num;
1860 ucontrol->value.integer.value[0] = wcd->port_enable[portidx];
1872 (struct soc_mixer_control *)kcontrol->private_value;
1873 int ch_idx = mixer->reg;
1875 int dai_id = mixer->shift;
1878 wcd = wcd938x->sdw_priv[dai_id];
1880 portidx = wcd->ch_info[ch_idx].port_num;
1881 if (ucontrol->value.integer.value[0])
1886 wcd->port_enable[portidx] = enable;
1916 dev_err(component->dev, "%s: invalid number of buttons: %d\n",
1925 dev_dbg(component->dev, "%s: btn_high[%d]: %d, vth: %d\n",
1980 /* min micbias voltage is 1V and maximum is 2.85V */
1982 return -EINVAL;
1984 return (micb_mv - 1000) / 50;
2007 return -EINVAL;
2009 mutex_lock(&wcd938x->micb_lock);
2011 * If requested micbias voltage is same as current micbias
2013 * per requested value. If micbias is already enabled, then
2014 * to avoid slow micbias ramp-up or down enable pull-up
2015 * momentarily, change the micbias value and then re-enable
2016 * micbias.
2025 ret = -EINVAL;
2049 * micbias
2054 mutex_unlock(&wcd938x->micb_lock);
2065 return -EINVAL;
2067 * If device tree micbias level is already above the minimum
2069 * not change the micbias, just return.
2071 if (wcd938x->micb2_mv >= WCD_MBHC_THR_HS_MICB_MV)
2074 micb_mv = req_en ? WCD_MBHC_THR_HS_MICB_MV : wcd938x->micb2_mv;
2093 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MBHC_ZDET, 0x20, 0x20);
2095 regmap_read(wcd938x->regmap, WCD938X_ANA_MBHC_RESULT_2, &val);
2100 regmap_read(wcd938x->regmap, WCD938X_ANA_MBHC_RESULT_1, &val1);
2102 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MBHC_ZDET, 0x20, 0x00);
2110 dev_err(component->dev, "Impedance detect ramp error, c1=%d, x1=0x%x\n",
2115 denom = (x1 * d1) - (1 << (14 - noff));
2121 dev_dbg(component->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%d (milliohm)\n",
2126 regmap_read(wcd938x->regmap,
2128 regmap_read(wcd938x->regmap,
2147 WCD938X_ZDET_MAXV_CTL_MASK, zdet_param->ldo_ctl);
2149 WCD938X_VTH_MASK, zdet_param->btn5);
2151 WCD938X_VTH_MASK, zdet_param->btn6);
2153 WCD938X_VTH_MASK, zdet_param->btn7);
2155 WCD938X_ZDET_RANGE_CTL_MASK, zdet_param->noff);
2157 0x0F, zdet_param->nshift);
2162 regmap_update_bits(wcd938x->regmap,
2164 dev_dbg(component->dev, "%s: ramp for HPH_L, noff = %d\n",
2165 __func__, zdet_param->noff);
2166 wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2167 regmap_update_bits(wcd938x->regmap,
2176 regmap_update_bits(wcd938x->regmap,
2178 dev_dbg(component->dev, "%s: ramp for HPH_R, noff = %d\n",
2179 __func__, zdet_param->noff);
2180 wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2181 regmap_update_bits(wcd938x->regmap,
2200 q1_cal = (10000 - ((q1 & 0x7F) * 25));
2238 regmap_update_bits(wcd938x->regmap,
2242 /* For NO-jack, disable L_DET_EN before Z-det measurements */
2243 if (wcd938x->mbhc_cfg.hphl_swh)
2244 regmap_update_bits(wcd938x->regmap,
2248 regmap_update_bits(wcd938x->regmap,
2254 regmap_update_bits(wcd938x->regmap,
2291 dev_dbg(component->dev, "%s: impedance on HPH_L = %d(ohms)\n",
2298 (zdet_param_ptr->noff == 0x6)) ||
2323 dev_dbg(component->dev, "%s: impedance on HPH_R = %d(ohms)\n",
2329 dev_dbg(component->dev,
2338 dev_dbg(component->dev,
2341 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2360 z_diff1 = (z1Ls > zMono) ? (z1Ls - zMono) : (zMono - z1Ls);
2361 z_diff2 = ((*zl) > z1Ls) ? ((*zl) - z1Ls) : (z1Ls - (*zl));
2363 dev_dbg(component->dev, "%s: stereo plug type detected\n",
2365 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_STEREO);
2367 dev_dbg(component->dev, "%s: MONO plug type detected\n",
2369 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2373 regmap_update_bits(wcd938x->regmap,
2380 regmap_update_bits(wcd938x->regmap,
2383 /* For NO-jack, re-enable L_DET_EN after Z-det measurements */
2384 if (wcd938x->mbhc_cfg.hphl_swh)
2385 regmap_update_bits(wcd938x->regmap,
2391 regmap_update_bits(wcd938x->regmap,
2424 if (wcd938x->mbhc_cfg.moist_rref == R_OFF) {
2431 if (!wcd938x->mbhc_cfg.hphl_swh) {
2432 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2440 WCD938X_M_RTH_CTL_MASK, wcd938x->mbhc_cfg.moist_rref);
2449 WCD938X_M_RTH_CTL_MASK, wcd938x->mbhc_cfg.moist_rref);
2460 if (wcd938x->mbhc_cfg.moist_rref == R_OFF) {
2467 if (!wcd938x->mbhc_cfg.hphl_swh) {
2468 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2524 ucontrol->value.integer.value[0] = wcd_mbhc_get_hph_type(wcd938x->wcd_mbhc);
2539 mc = (struct soc_mixer_control *)(kcontrol->private_value);
2540 hphr = mc->shift;
2541 wcd_mbhc_get_impedance(wcd938x->wcd_mbhc, &zl, &zr);
2542 dev_dbg(component->dev, "%s: zl=%u(ohms), zr=%u(ohms)\n", __func__, zl, zr);
2543 ucontrol->value.integer.value[0] = hphr ? zr : zl;
2563 struct wcd_mbhc_intr *intr_ids = &wcd938x->intr_ids;
2565 intr_ids->mbhc_sw_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2567 intr_ids->mbhc_btn_press_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2569 intr_ids->mbhc_btn_release_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2571 intr_ids->mbhc_hs_ins_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2573 intr_ids->mbhc_hs_rem_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2575 intr_ids->hph_left_ocp = regmap_irq_get_virq(wcd938x->irq_chip,
2577 intr_ids->hph_right_ocp = regmap_irq_get_virq(wcd938x->irq_chip,
2580 wcd938x->wcd_mbhc = wcd_mbhc_init(component, &mbhc_cb, intr_ids, wcd_mbhc_fields, true);
2581 if (IS_ERR(wcd938x->wcd_mbhc))
2582 return PTR_ERR(wcd938x->wcd_mbhc);
2596 wcd_mbhc_deinit(wcd938x->wcd_mbhc);
2767 /* micbias widgets*/
2785 /* micbias pull up widgets*/
2983 /* set micbias voltage */
2984 vout_ctl_1 = wcd938x_get_micb_vout_ctl_val(wcd938x->micb1_mv);
2985 vout_ctl_2 = wcd938x_get_micb_vout_ctl_val(wcd938x->micb2_mv);
2986 vout_ctl_3 = wcd938x_get_micb_vout_ctl_val(wcd938x->micb3_mv);
2987 vout_ctl_4 = wcd938x_get_micb_vout_ctl_val(wcd938x->micb4_mv);
2989 return -EINVAL;
2991 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB1,
2993 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB2,
2995 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB3,
2997 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB4,
3029 wcd->virq = irq_domain_create_linear(NULL, 1, &wcd_domain_ops, NULL);
3030 if (!(wcd->virq)) {
3032 return -EINVAL;
3035 return devm_regmap_add_irq_chip(dev, wcd->regmap,
3036 irq_create_mapping(wcd->virq, 0),
3038 &wcd->irq_chip);
3044 struct sdw_slave *tx_sdw_dev = wcd938x->tx_sdw_dev;
3045 struct device *dev = component->dev;
3050 time_left = wait_for_completion_timeout(&tx_sdw_dev->initialization_complete,
3054 return -ETIMEDOUT;
3057 snd_soc_component_init_regmap(component, wcd938x->regmap);
3067 wcd938x->clsh_info = wcd_clsh_ctrl_alloc(component, WCD938X);
3068 if (IS_ERR(wcd938x->clsh_info)) {
3070 return PTR_ERR(wcd938x->clsh_info);
3076 regmap_write(wcd938x->regmap,
3082 wcd938x->hphr_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3084 wcd938x->hphl_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3086 wcd938x->aux_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3090 ret = request_threaded_irq(wcd938x->hphr_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3098 ret = request_threaded_irq(wcd938x->hphl_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3106 ret = request_threaded_irq(wcd938x->aux_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3115 disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
3116 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
3117 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
3124 dev_err(component->dev,
3134 dev_err(component->dev,
3146 dev_err(component->dev, "mbhc initialization failed\n");
3153 free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3155 free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3157 free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3159 wcd_clsh_ctrl_free(wcd938x->clsh_info);
3170 free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3171 free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3172 free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3174 wcd_clsh_ctrl_free(wcd938x->clsh_info);
3180 struct wcd938x_priv *wcd = dev_get_drvdata(comp->dev);
3183 return wcd_mbhc_start(wcd->wcd_mbhc, &wcd->mbhc_cfg, jack);
3185 wcd_mbhc_stop(wcd->wcd_mbhc);
3206 struct device_node *np = dev->of_node;
3210 rc = of_property_read_u32(np, "qcom,micbias1-microvolt", &prop_val);
3212 wcd->micb1_mv = prop_val/1000;
3216 rc = of_property_read_u32(np, "qcom,micbias2-microvolt", &prop_val);
3218 wcd->micb2_mv = prop_val/1000;
3222 rc = of_property_read_u32(np, "qcom,micbias3-microvolt", &prop_val);
3224 wcd->micb3_mv = prop_val/1000;
3228 rc = of_property_read_u32(np, "qcom,micbias4-microvolt", &prop_val);
3230 wcd->micb4_mv = prop_val/1000;
3238 struct device *dev = component->dev;
3241 if (wcd938x->us_euro_mux) {
3242 if (wcd938x->mux_setup_done)
3243 mux_control_deselect(wcd938x->us_euro_mux);
3245 ret = mux_control_try_select(wcd938x->us_euro_mux, !wcd938x->mux_state);
3248 wcd938x->mux_setup_done = false;
3251 wcd938x->mux_setup_done = true;
3253 gpiod_set_value(wcd938x->us_euro_gpio, !wcd938x->mux_state);
3256 wcd938x->mux_state = !wcd938x->mux_state;
3264 struct wcd_mbhc_config *cfg = &wcd938x->mbhc_cfg;
3267 wcd938x->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
3268 if (IS_ERR(wcd938x->reset_gpio))
3269 return dev_err_probe(dev, PTR_ERR(wcd938x->reset_gpio),
3272 if (of_property_present(dev->of_node, "mux-controls")) {
3273 wcd938x->us_euro_mux = devm_mux_control_get(dev, NULL);
3274 if (IS_ERR(wcd938x->us_euro_mux)) {
3275 ret = PTR_ERR(wcd938x->us_euro_mux);
3279 ret = mux_control_try_select(wcd938x->us_euro_mux, wcd938x->mux_state);
3284 wcd938x->mux_setup_done = true;
3286 wcd938x->us_euro_gpio = devm_gpiod_get_optional(dev, "us-euro", GPIOD_OUT_LOW);
3287 if (IS_ERR(wcd938x->us_euro_gpio))
3288 return dev_err_probe(dev, PTR_ERR(wcd938x->us_euro_gpio),
3289 "us-euro swap Control GPIO not found\n");
3292 cfg->swap_gnd_mic = wcd938x_swap_gnd_mic;
3301 cfg->mbhc_micbias = MIC_BIAS_2;
3302 cfg->anc_micbias = MIC_BIAS_2;
3303 cfg->v_hs_max = WCD_MBHC_HS_V_MAX;
3304 cfg->num_btn = WCD938X_MBHC_MAX_BUTTONS;
3305 cfg->micb_mv = wcd938x->micb2_mv;
3306 cfg->linein_th = 5000;
3307 cfg->hs_thr = 1700;
3308 cfg->hph_thr = 50;
3317 gpiod_set_value(wcd938x->reset_gpio, 1);
3320 gpiod_set_value(wcd938x->reset_gpio, 0);
3331 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3332 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3340 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3341 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3349 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3350 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3364 .name = "wcd938x-sdw-rx",
3377 .name = "wcd938x-sdw-tx",
3403 wcd938x->rxdev = wcd938x_sdw_device_get(wcd938x->rxnode);
3404 if (!wcd938x->rxdev) {
3406 ret = -EINVAL;
3409 wcd938x->sdw_priv[AIF1_PB] = dev_get_drvdata(wcd938x->rxdev);
3410 wcd938x->sdw_priv[AIF1_PB]->wcd938x = wcd938x;
3412 wcd938x->txdev = wcd938x_sdw_device_get(wcd938x->txnode);
3413 if (!wcd938x->txdev) {
3415 ret = -EINVAL;
3418 wcd938x->sdw_priv[AIF1_CAP] = dev_get_drvdata(wcd938x->txdev);
3419 wcd938x->sdw_priv[AIF1_CAP]->wcd938x = wcd938x;
3420 wcd938x->tx_sdw_dev = dev_to_sdw_dev(wcd938x->txdev);
3422 /* As TX is main CSR reg interface, which should not be suspended first.
3424 if (!device_link_add(wcd938x->rxdev, wcd938x->txdev, DL_FLAG_STATELESS |
3427 ret = -EINVAL;
3431 if (!device_link_add(dev, wcd938x->txdev, DL_FLAG_STATELESS |
3434 ret = -EINVAL;
3438 if (!device_link_add(dev, wcd938x->rxdev, DL_FLAG_STATELESS |
3441 ret = -EINVAL;
3445 wcd938x->regmap = dev_get_regmap(&wcd938x->tx_sdw_dev->dev, NULL);
3446 if (!wcd938x->regmap) {
3448 ret = -EINVAL;
3458 wcd938x->sdw_priv[AIF1_PB]->slave_irq = wcd938x->virq;
3459 wcd938x->sdw_priv[AIF1_CAP]->slave_irq = wcd938x->virq;
3463 dev_err(dev, "%s: bad micbias pdata\n", __func__);
3478 device_link_remove(dev, wcd938x->rxdev);
3480 device_link_remove(dev, wcd938x->txdev);
3482 device_link_remove(wcd938x->rxdev, wcd938x->txdev);
3484 put_device(wcd938x->txdev);
3486 put_device(wcd938x->rxdev);
3498 device_link_remove(dev, wcd938x->txdev);
3499 device_link_remove(dev, wcd938x->rxdev);
3500 device_link_remove(wcd938x->rxdev, wcd938x->txdev);
3501 put_device(wcd938x->txdev);
3502 put_device(wcd938x->rxdev);
3517 np = dev->of_node;
3519 wcd938x->rxnode = of_parse_phandle(np, "qcom,rx-device", 0);
3520 if (!wcd938x->rxnode) {
3521 dev_err(dev, "%s: Rx-device node not defined\n", __func__);
3522 return -ENODEV;
3525 of_node_get(wcd938x->rxnode);
3527 component_compare_of, wcd938x->rxnode);
3529 wcd938x->txnode = of_parse_phandle(np, "qcom,tx-device", 0);
3530 if (!wcd938x->txnode) {
3531 dev_err(dev, "%s: Tx-device node not defined\n", __func__);
3532 return -ENODEV;
3534 of_node_get(wcd938x->txnode);
3536 component_compare_of, wcd938x->txnode);
3544 struct device *dev = &pdev->dev;
3550 return -ENOMEM;
3553 mutex_init(&wcd938x->micb_lock);
3581 struct device *dev = &pdev->dev;
3590 if (wcd938x->us_euro_mux && wcd938x->mux_setup_done)
3591 mux_control_deselect(wcd938x->us_euro_mux);
3596 { .compatible = "qcom,wcd9380-codec" },
3597 { .compatible = "qcom,wcd9385-codec" },