Lines Matching +full:va +full:- +full:dai +full:- +full:link
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-common.h"
26 #include "wcd-mbhc-v2.h"
184 "vdd-rxtx", "vdd-io", "vdd-buck", "vdd-mic-bias",
187 static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(ear_pa_gain, 600, -1800);
188 static const DECLARE_TLV_DB_SCALE(line_gain, -3000, 150, 0);
344 struct regmap *rm = wcd938x->regmap;
403 port_num = ch_info->port_num;
404 ch_mask = ch_info->ch_mask;
406 port_config->num = port_num;
409 port_config->ch_mask |= ch_mask;
411 port_config->ch_mask &= ~ch_mask;
418 return wcd938x_sdw_connect_port(&wcd->ch_info[ch_id],
419 &wcd->port_config[port_num - 1],
427 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
466 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
485 if (wcd938x->comp1_enable) {
490 if (!wcd938x->comp2_enable || (snd_soc_component_read(component,
520 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
539 if (wcd938x->comp2_enable) {
544 if (!wcd938x->comp1_enable ||
574 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
579 wcd938x->ear_rx_path =
582 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
602 if (wcd938x->comp1_enable)
609 if (wcd938x->flyback_cur_det_disable == 0)
612 wcd938x->flyback_cur_det_disable++;
613 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
616 wcd938x->hph_mode);
619 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
633 if (wcd938x->comp1_enable)
653 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
667 if (wcd938x->flyback_cur_det_disable == 0)
670 wcd938x->flyback_cur_det_disable++;
671 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
674 wcd938x->hph_mode);
689 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
691 int hph_mode = wcd938x->hph_mode;
695 if (wcd938x->ldoh)
698 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
700 wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);
710 wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
713 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
724 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
725 if (!wcd938x->comp2_enable)
735 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
744 enable_irq(wcd938x->hphr_pdm_wd_int);
747 disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
753 if (!wcd938x->comp2_enable)
759 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
761 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
769 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
770 if (!wcd938x->comp2_enable)
774 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
776 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
782 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
784 if (wcd938x->ldoh)
796 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
798 int hph_mode = wcd938x->hph_mode;
802 if (wcd938x->ldoh)
805 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
807 wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);
816 wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
819 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
830 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
831 if (!wcd938x->comp1_enable)
840 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
850 enable_irq(wcd938x->hphl_pdm_wd_int);
853 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
859 if (!wcd938x->comp1_enable)
865 wcd_mbhc_event_notify(wcd938x->wcd_mbhc, WCD_EVENT_PRE_HPHL_PA_OFF);
866 set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
874 if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
875 if (!wcd938x->comp1_enable)
879 clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
881 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
887 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
889 if (wcd938x->ldoh)
901 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
903 int hph_mode = wcd938x->hph_mode;
918 enable_irq(wcd938x->aux_pdm_wd_int);
921 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
928 wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
933 wcd938x->flyback_cur_det_disable--;
934 if (wcd938x->flyback_cur_det_disable == 0)
945 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
947 int hph_mode = wcd938x->hph_mode;
955 wcd938x->ear_rx_path = snd_soc_component_read(component,
957 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
964 if (!wcd938x->comp1_enable)
978 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
979 enable_irq(wcd938x->aux_pdm_wd_int);
981 enable_irq(wcd938x->hphl_pdm_wd_int);
984 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
985 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
987 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
990 if (!wcd938x->comp1_enable)
995 if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
1002 wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
1005 wcd938x->flyback_cur_det_disable--;
1006 if (wcd938x->flyback_cur_det_disable == 0)
1019 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1023 switch (w->shift) {
1053 dev_err(component->dev, "%s: Invalid DMIC Selection\n",
1055 return -EINVAL;
1090 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1095 bank = sdw_slave_get_current_bank(wcd938x->sdw_priv[AIF1_CAP]->sdev);
1099 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1102 if (test_bit(WCD_ADC1, &wcd938x->status_mask))
1103 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC1]];
1104 if (test_bit(WCD_ADC2, &wcd938x->status_mask))
1105 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC2]];
1106 if (test_bit(WCD_ADC3, &wcd938x->status_mask))
1107 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC3]];
1108 if (test_bit(WCD_ADC4, &wcd938x->status_mask))
1109 mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC4]];
1126 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1164 ret = -EINVAL;
1173 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1184 set_bit(w->shift, &wcd938x->status_mask);
1189 clear_bit(w->shift, &wcd938x->status_mask);
1228 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1240 wcd938x_tx_channel_config(component, w->shift, 1);
1241 mode = wcd938x_get_adc_mode(wcd938x->tx_mode[w->shift]);
1243 dev_info(component->dev, "Invalid ADC mode\n");
1244 return -EINVAL;
1246 switch (w->shift) {
1283 wcd938x_tx_channel_config(component, w->shift, 0);
1286 switch (w->shift) {
1335 int micb_index = micb_num - 1;
1352 dev_err(component->dev, "%s: Invalid micbias number: %d\n",
1354 return -EINVAL;
1359 wcd938x->pullup_ref[micb_index]++;
1360 if ((wcd938x->pullup_ref[micb_index] == 1) &&
1361 (wcd938x->micb_ref[micb_index] == 0))
1367 if (wcd938x->pullup_ref[micb_index] > 0)
1368 wcd938x->pullup_ref[micb_index]--;
1370 if ((wcd938x->pullup_ref[micb_index] == 0) &&
1371 (wcd938x->micb_ref[micb_index] == 0))
1376 wcd938x->micb_ref[micb_index]++;
1377 if (wcd938x->micb_ref[micb_index] == 1) {
1392 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1396 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1402 if (wcd938x->micb_ref[micb_index] > 0)
1403 wcd938x->micb_ref[micb_index]--;
1405 if ((wcd938x->micb_ref[micb_index] == 0) &&
1406 (wcd938x->pullup_ref[micb_index] > 0))
1410 else if ((wcd938x->micb_ref[micb_index] == 0) &&
1411 (wcd938x->pullup_ref[micb_index] == 0)) {
1413 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1419 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1423 wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
1435 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1436 int micb_num = w->shift;
1458 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1459 int micb_num = w->shift;
1484 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1485 int path = e->shift_l;
1487 ucontrol->value.enumerated.item[0] = wcd938x->tx_mode[path];
1497 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1498 int path = e->shift_l;
1500 if (wcd938x->tx_mode[path] == ucontrol->value.enumerated.item[0])
1503 wcd938x->tx_mode[path] = ucontrol->value.enumerated.item[0];
1514 ucontrol->value.enumerated.item[0] = wcd938x->hph_mode;
1525 if (wcd938x->hph_mode == ucontrol->value.enumerated.item[0])
1528 wcd938x->hph_mode = ucontrol->value.enumerated.item[0];
1539 if (wcd938x->comp1_enable) {
1540 dev_err(component->dev, "Can not set EAR PA Gain, compander1 is enabled\n");
1541 return -EINVAL;
1546 ucontrol->value.integer.value[0]);
1560 mc = (struct soc_mixer_control *)(kcontrol->private_value);
1561 hphr = mc->shift;
1564 ucontrol->value.integer.value[0] = wcd938x->comp2_enable;
1566 ucontrol->value.integer.value[0] = wcd938x->comp1_enable;
1577 int value = ucontrol->value.integer.value[0];
1582 mc = (struct soc_mixer_control *)(kcontrol->private_value);
1583 hphr = mc->shift;
1585 wcd = wcd938x->sdw_priv[AIF1_PB];
1588 wcd938x->comp2_enable = value;
1590 wcd938x->comp1_enable = value;
1592 portidx = wcd->ch_info[mc->reg].port_num;
1595 wcd938x_connect_port(wcd, portidx, mc->reg, true);
1597 wcd938x_connect_port(wcd, portidx, mc->reg, false);
1608 ucontrol->value.integer.value[0] = wcd938x->ldoh;
1619 if (wcd938x->ldoh == ucontrol->value.integer.value[0])
1622 wcd938x->ldoh = ucontrol->value.integer.value[0];
1849 struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1850 int dai_id = mixer->shift;
1851 int portidx, ch_idx = mixer->reg;
1854 wcd = wcd938x->sdw_priv[dai_id];
1855 portidx = wcd->ch_info[ch_idx].port_num;
1857 ucontrol->value.integer.value[0] = wcd->port_enable[portidx];
1869 (struct soc_mixer_control *)kcontrol->private_value;
1870 int ch_idx = mixer->reg;
1872 int dai_id = mixer->shift;
1875 wcd = wcd938x->sdw_priv[dai_id];
1877 portidx = wcd->ch_info[ch_idx].port_num;
1878 if (ucontrol->value.integer.value[0])
1883 wcd->port_enable[portidx] = enable;
1913 dev_err(component->dev, "%s: invalid number of buttons: %d\n",
1922 dev_dbg(component->dev, "%s: btn_high[%d]: %d, vth: %d\n",
1995 return -EINVAL;
1997 mutex_lock(&wcd938x->micb_lock);
2002 * to avoid slow micbias ramp-up or down enable pull-up
2003 * momentarily, change the micbias value and then re-enable
2011 req_vout_ctl = wcd_get_micb_vout_ctl_val(component->dev, req_volt);
2013 ret = -EINVAL;
2042 mutex_unlock(&wcd938x->micb_lock);
2053 return -EINVAL;
2059 if (wcd938x->common.micb_mv[2] >= WCD_MBHC_THR_HS_MICB_MV)
2062 micb_mv = req_en ? WCD_MBHC_THR_HS_MICB_MV : wcd938x->common.micb_mv[2];
2081 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MBHC_ZDET, 0x20, 0x20);
2083 regmap_read(wcd938x->regmap, WCD938X_ANA_MBHC_RESULT_2, &val);
2088 regmap_read(wcd938x->regmap, WCD938X_ANA_MBHC_RESULT_1, &val1);
2090 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MBHC_ZDET, 0x20, 0x00);
2098 dev_err(component->dev, "Impedance detect ramp error, c1=%d, x1=0x%x\n",
2103 denom = (x1 * d1) - (1 << (14 - noff));
2109 dev_dbg(component->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%d (milliohm)\n",
2114 regmap_read(wcd938x->regmap,
2116 regmap_read(wcd938x->regmap,
2135 WCD938X_ZDET_MAXV_CTL_MASK, zdet_param->ldo_ctl);
2137 WCD938X_VTH_MASK, zdet_param->btn5);
2139 WCD938X_VTH_MASK, zdet_param->btn6);
2141 WCD938X_VTH_MASK, zdet_param->btn7);
2143 WCD938X_ZDET_RANGE_CTL_MASK, zdet_param->noff);
2145 0x0F, zdet_param->nshift);
2150 regmap_update_bits(wcd938x->regmap,
2152 dev_dbg(component->dev, "%s: ramp for HPH_L, noff = %d\n",
2153 __func__, zdet_param->noff);
2154 wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2155 regmap_update_bits(wcd938x->regmap,
2164 regmap_update_bits(wcd938x->regmap,
2166 dev_dbg(component->dev, "%s: ramp for HPH_R, noff = %d\n",
2167 __func__, zdet_param->noff);
2168 wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2169 regmap_update_bits(wcd938x->regmap,
2188 q1_cal = (10000 - ((q1 & 0x7F) * 25));
2226 regmap_update_bits(wcd938x->regmap,
2230 /* For NO-jack, disable L_DET_EN before Z-det measurements */
2231 if (wcd938x->mbhc_cfg.hphl_swh)
2232 regmap_update_bits(wcd938x->regmap,
2236 regmap_update_bits(wcd938x->regmap,
2242 regmap_update_bits(wcd938x->regmap,
2279 dev_dbg(component->dev, "%s: impedance on HPH_L = %d(ohms)\n",
2286 (zdet_param_ptr->noff == 0x6)) ||
2311 dev_dbg(component->dev, "%s: impedance on HPH_R = %d(ohms)\n",
2317 dev_dbg(component->dev,
2326 dev_dbg(component->dev,
2329 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2348 z_diff1 = (z1Ls > zMono) ? (z1Ls - zMono) : (zMono - z1Ls);
2349 z_diff2 = ((*zl) > z1Ls) ? ((*zl) - z1Ls) : (z1Ls - (*zl));
2351 dev_dbg(component->dev, "%s: stereo plug type detected\n",
2353 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_STEREO);
2355 dev_dbg(component->dev, "%s: MONO plug type detected\n",
2357 wcd_mbhc_set_hph_type(wcd938x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2361 regmap_update_bits(wcd938x->regmap,
2368 regmap_update_bits(wcd938x->regmap,
2371 /* For NO-jack, re-enable L_DET_EN after Z-det measurements */
2372 if (wcd938x->mbhc_cfg.hphl_swh)
2373 regmap_update_bits(wcd938x->regmap,
2379 regmap_update_bits(wcd938x->regmap,
2412 if (wcd938x->mbhc_cfg.moist_rref == R_OFF) {
2419 if (!wcd938x->mbhc_cfg.hphl_swh) {
2420 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2428 WCD938X_M_RTH_CTL_MASK, wcd938x->mbhc_cfg.moist_rref);
2437 WCD938X_M_RTH_CTL_MASK, wcd938x->mbhc_cfg.moist_rref);
2448 if (wcd938x->mbhc_cfg.moist_rref == R_OFF) {
2455 if (!wcd938x->mbhc_cfg.hphl_swh) {
2456 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2512 ucontrol->value.integer.value[0] = wcd_mbhc_get_hph_type(wcd938x->wcd_mbhc);
2527 mc = (struct soc_mixer_control *)(kcontrol->private_value);
2528 hphr = mc->shift;
2529 wcd_mbhc_get_impedance(wcd938x->wcd_mbhc, &zl, &zr);
2530 dev_dbg(component->dev, "%s: zl=%u(ohms), zr=%u(ohms)\n", __func__, zl, zr);
2531 ucontrol->value.integer.value[0] = hphr ? zr : zl;
2551 struct wcd_mbhc_intr *intr_ids = &wcd938x->intr_ids;
2553 intr_ids->mbhc_sw_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2555 intr_ids->mbhc_btn_press_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2557 intr_ids->mbhc_btn_release_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2559 intr_ids->mbhc_hs_ins_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2561 intr_ids->mbhc_hs_rem_intr = regmap_irq_get_virq(wcd938x->irq_chip,
2563 intr_ids->hph_left_ocp = regmap_irq_get_virq(wcd938x->irq_chip,
2565 intr_ids->hph_right_ocp = regmap_irq_get_virq(wcd938x->irq_chip,
2568 wcd938x->wcd_mbhc = wcd_mbhc_init(component, &mbhc_cb, intr_ids, wcd_mbhc_fields, true);
2569 if (IS_ERR(wcd938x->wcd_mbhc))
2570 return PTR_ERR(wcd938x->wcd_mbhc);
2584 wcd_mbhc_deinit(wcd938x->wcd_mbhc);
2774 SND_SOC_DAPM_SUPPLY("VA MIC BIAS1", SND_SOC_NOPM, MIC_BIAS_1, 0,
2778 SND_SOC_DAPM_SUPPLY("VA MIC BIAS2", SND_SOC_NOPM, MIC_BIAS_2, 0,
2782 SND_SOC_DAPM_SUPPLY("VA MIC BIAS3", SND_SOC_NOPM, MIC_BIAS_3, 0,
2786 SND_SOC_DAPM_SUPPLY("VA MIC BIAS4", SND_SOC_NOPM, MIC_BIAS_4, 0,
2969 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB1,
2970 WCD938X_MICB_VOUT_MASK, wcd938x->common.micb_vout[0]);
2971 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB2,
2972 WCD938X_MICB_VOUT_MASK, wcd938x->common.micb_vout[1]);
2973 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB3,
2974 WCD938X_MICB_VOUT_MASK, wcd938x->common.micb_vout[2]);
2975 regmap_update_bits(wcd938x->regmap, WCD938X_ANA_MICB4,
2976 WCD938X_MICB_VOUT_MASK, wcd938x->common.micb_vout[3]);
3005 wcd->virq = irq_domain_create_linear(NULL, 1, &wcd_domain_ops, NULL);
3006 if (!(wcd->virq)) {
3008 return -EINVAL;
3011 return devm_regmap_add_irq_chip(dev, wcd->regmap,
3012 irq_create_mapping(wcd->virq, 0),
3014 &wcd->irq_chip);
3020 struct sdw_slave *tx_sdw_dev = wcd938x->tx_sdw_dev;
3021 struct device *dev = component->dev;
3026 time_left = wait_for_completion_timeout(&tx_sdw_dev->initialization_complete,
3030 return -ETIMEDOUT;
3033 snd_soc_component_init_regmap(component, wcd938x->regmap);
3043 wcd938x->clsh_info = wcd_clsh_ctrl_alloc(component, WCD938X);
3044 if (IS_ERR(wcd938x->clsh_info)) {
3046 return PTR_ERR(wcd938x->clsh_info);
3052 regmap_write(wcd938x->regmap,
3058 wcd938x->hphr_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3060 wcd938x->hphl_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3062 wcd938x->aux_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3066 ret = request_threaded_irq(wcd938x->hphr_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3074 ret = request_threaded_irq(wcd938x->hphl_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3082 ret = request_threaded_irq(wcd938x->aux_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3091 disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
3092 disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
3093 disable_irq_nosync(wcd938x->aux_pdm_wd_int);
3100 dev_err(component->dev,
3110 dev_err(component->dev,
3122 dev_err(component->dev, "mbhc initialization failed\n");
3129 free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3131 free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3133 free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3135 wcd_clsh_ctrl_free(wcd938x->clsh_info);
3146 free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3147 free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3148 free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3150 wcd_clsh_ctrl_free(wcd938x->clsh_info);
3156 struct wcd938x_priv *wcd = dev_get_drvdata(comp->dev);
3159 return wcd_mbhc_start(wcd->wcd_mbhc, &wcd->mbhc_cfg, jack);
3161 wcd_mbhc_stop(wcd->wcd_mbhc);
3183 struct device *dev = component->dev;
3186 if (wcd938x->us_euro_mux) {
3187 if (wcd938x->mux_setup_done)
3188 mux_control_deselect(wcd938x->us_euro_mux);
3190 ret = mux_control_try_select(wcd938x->us_euro_mux, !wcd938x->mux_state);
3193 wcd938x->mux_setup_done = false;
3196 wcd938x->mux_setup_done = true;
3198 gpiod_set_value(wcd938x->us_euro_gpio, !wcd938x->mux_state);
3201 wcd938x->mux_state = !wcd938x->mux_state;
3209 struct wcd_mbhc_config *cfg = &wcd938x->mbhc_cfg;
3212 wcd938x->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
3213 if (IS_ERR(wcd938x->reset_gpio))
3214 return dev_err_probe(dev, PTR_ERR(wcd938x->reset_gpio),
3217 if (of_property_present(dev->of_node, "mux-controls")) {
3218 wcd938x->us_euro_mux = devm_mux_control_get(dev, NULL);
3219 if (IS_ERR(wcd938x->us_euro_mux)) {
3220 ret = PTR_ERR(wcd938x->us_euro_mux);
3224 ret = mux_control_try_select(wcd938x->us_euro_mux, wcd938x->mux_state);
3229 wcd938x->mux_setup_done = true;
3231 wcd938x->us_euro_gpio = devm_gpiod_get_optional(dev, "us-euro", GPIOD_OUT_LOW);
3232 if (IS_ERR(wcd938x->us_euro_gpio))
3233 return dev_err_probe(dev, PTR_ERR(wcd938x->us_euro_gpio),
3234 "us-euro swap Control GPIO not found\n");
3237 cfg->swap_gnd_mic = wcd938x_swap_gnd_mic;
3244 ret = wcd_dt_parse_micbias_info(&wcd938x->common);
3248 cfg->mbhc_micbias = MIC_BIAS_2;
3249 cfg->anc_micbias = MIC_BIAS_2;
3250 cfg->v_hs_max = WCD_MBHC_HS_V_MAX;
3251 cfg->num_btn = WCD938X_MBHC_MAX_BUTTONS;
3252 cfg->micb_mv = wcd938x->common.micb_mv[2];
3253 cfg->linein_th = 5000;
3254 cfg->hs_thr = 1700;
3255 cfg->hph_thr = 50;
3264 gpiod_set_value(wcd938x->reset_gpio, 1);
3267 gpiod_set_value(wcd938x->reset_gpio, 0);
3276 struct snd_soc_dai *dai)
3278 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3279 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3281 return wcd938x_sdw_hw_params(wcd, substream, params, dai);
3285 struct snd_soc_dai *dai)
3287 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3288 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3290 return wcd938x_sdw_free(wcd, substream, dai);
3293 static int wcd938x_codec_set_sdw_stream(struct snd_soc_dai *dai,
3296 struct wcd938x_priv *wcd938x = dev_get_drvdata(dai->dev);
3297 struct wcd938x_sdw_priv *wcd = wcd938x->sdw_priv[dai->id];
3299 return wcd938x_sdw_set_sdw_stream(wcd, dai, stream, direction);
3311 .name = "wcd938x-sdw-rx",
3324 .name = "wcd938x-sdw-tx",
3350 wcd938x->rxdev = of_sdw_find_device_by_node(wcd938x->rxnode);
3351 if (!wcd938x->rxdev) {
3353 ret = -EINVAL;
3356 wcd938x->sdw_priv[AIF1_PB] = dev_get_drvdata(wcd938x->rxdev);
3357 wcd938x->sdw_priv[AIF1_PB]->wcd938x = wcd938x;
3359 wcd938x->txdev = of_sdw_find_device_by_node(wcd938x->txnode);
3360 if (!wcd938x->txdev) {
3362 ret = -EINVAL;
3365 wcd938x->sdw_priv[AIF1_CAP] = dev_get_drvdata(wcd938x->txdev);
3366 wcd938x->sdw_priv[AIF1_CAP]->wcd938x = wcd938x;
3367 wcd938x->tx_sdw_dev = dev_to_sdw_dev(wcd938x->txdev);
3370 * expicilty add the dependency link */
3371 if (!device_link_add(wcd938x->rxdev, wcd938x->txdev, DL_FLAG_STATELESS |
3374 ret = -EINVAL;
3378 if (!device_link_add(dev, wcd938x->txdev, DL_FLAG_STATELESS |
3381 ret = -EINVAL;
3385 if (!device_link_add(dev, wcd938x->rxdev, DL_FLAG_STATELESS |
3388 ret = -EINVAL;
3392 wcd938x->regmap = wcd938x->sdw_priv[AIF1_CAP]->regmap;
3393 if (!wcd938x->regmap) {
3395 ret = -EINVAL;
3405 wcd938x->sdw_priv[AIF1_PB]->slave_irq = wcd938x->virq;
3406 wcd938x->sdw_priv[AIF1_CAP]->slave_irq = wcd938x->virq;
3421 device_link_remove(dev, wcd938x->rxdev);
3423 device_link_remove(dev, wcd938x->txdev);
3425 device_link_remove(wcd938x->rxdev, wcd938x->txdev);
3427 put_device(wcd938x->txdev);
3429 put_device(wcd938x->rxdev);
3441 device_link_remove(dev, wcd938x->txdev);
3442 device_link_remove(dev, wcd938x->rxdev);
3443 device_link_remove(wcd938x->rxdev, wcd938x->txdev);
3444 put_device(wcd938x->txdev);
3445 put_device(wcd938x->rxdev);
3460 np = dev->of_node;
3462 wcd938x->rxnode = of_parse_phandle(np, "qcom,rx-device", 0);
3463 if (!wcd938x->rxnode) {
3464 dev_err(dev, "%s: Rx-device node not defined\n", __func__);
3465 return -ENODEV;
3468 of_node_get(wcd938x->rxnode);
3470 component_compare_of, wcd938x->rxnode);
3472 wcd938x->txnode = of_parse_phandle(np, "qcom,tx-device", 0);
3473 if (!wcd938x->txnode) {
3474 dev_err(dev, "%s: Tx-device node not defined\n", __func__);
3475 return -ENODEV;
3477 of_node_get(wcd938x->txnode);
3479 component_compare_of, wcd938x->txnode);
3487 struct device *dev = &pdev->dev;
3493 return -ENOMEM;
3496 mutex_init(&wcd938x->micb_lock);
3497 wcd938x->common.dev = dev;
3498 wcd938x->common.max_bias = 4;
3526 struct device *dev = &pdev->dev;
3535 if (wcd938x->us_euro_mux && wcd938x->mux_setup_done)
3536 mux_control_deselect(wcd938x->us_euro_mux);
3541 { .compatible = "qcom,wcd9380-codec" },
3542 { .compatible = "qcom,wcd9385-codec" },