Lines Matching +full:va +full:- +full:dai +full:- +full:link
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2018-2021, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2022-2023, Qualcomm Innovation Center, Inc. All rights reserved.
25 #include <sound/soc-dapm.h>
30 #include "wcd-clsh-v2.h"
31 #include "wcd-common.h"
32 #include "wcd-mbhc-v2.h"
215 "vdd-rxtx", "vdd-io", "vdd-buck", "vdd-mic-bias", "vdd-px",
218 static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(ear_pa_gain, 600, -1800);
422 port_num = ch_info->port_num;
423 ch_mask = ch_info->ch_mask;
425 port_config->num = port_num;
428 port_config->ch_mask |= ch_mask;
430 port_config->ch_mask &= ~ch_mask;
437 return wcd939x_sdw_connect_port(&wcd->ch_info[ch_id],
438 &wcd->port_config[port_num - 1],
446 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
506 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
521 if (wcd939x->comp1_enable) {
527 if (!wcd939x->comp2_enable ||
560 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
563 dev_dbg(component->dev, "%s wname: %s event: %d\n", __func__,
564 w->name, event);
578 if (wcd939x->comp2_enable) {
584 if (!wcd939x->comp1_enable ||
616 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
629 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
648 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
650 int hph_mode = wcd939x->hph_mode;
654 if (wcd939x->ldoh)
658 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
660 wcd_clsh_set_hph_mode(wcd939x->clsh_info, CLS_H_HIFI);
679 set_bit(HPH_PA_DELAY, &wcd939x->status_mask);
689 if (test_bit(HPH_PA_DELAY, &wcd939x->status_mask)) {
690 if (!wcd939x->comp2_enable)
701 clear_bit(HPH_PA_DELAY, &wcd939x->status_mask);
711 enable_irq(wcd939x->hphr_pdm_wd_int);
714 disable_irq_nosync(wcd939x->hphr_pdm_wd_int);
720 if (!wcd939x->comp2_enable)
728 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
730 set_bit(HPH_PA_DELAY, &wcd939x->status_mask);
738 if (test_bit(HPH_PA_DELAY, &wcd939x->status_mask)) {
739 if (!wcd939x->comp2_enable)
743 clear_bit(HPH_PA_DELAY, &wcd939x->status_mask);
745 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
753 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_POST_PA,
755 if (wcd939x->ldoh)
768 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
770 int hph_mode = wcd939x->hph_mode;
772 dev_dbg(component->dev, "%s wname: %s event: %d\n", __func__,
773 w->name, event);
777 if (wcd939x->ldoh)
780 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
782 wcd_clsh_set_hph_mode(wcd939x->clsh_info, CLS_H_HIFI);
802 set_bit(HPH_PA_DELAY, &wcd939x->status_mask);
812 if (test_bit(HPH_PA_DELAY, &wcd939x->status_mask)) {
813 if (!wcd939x->comp1_enable)
823 clear_bit(HPH_PA_DELAY, &wcd939x->status_mask);
832 enable_irq(wcd939x->hphl_pdm_wd_int);
835 disable_irq_nosync(wcd939x->hphl_pdm_wd_int);
841 if (!wcd939x->comp1_enable)
849 wcd_mbhc_event_notify(wcd939x->wcd_mbhc, WCD_EVENT_PRE_HPHL_PA_OFF);
850 set_bit(HPH_PA_DELAY, &wcd939x->status_mask);
858 if (test_bit(HPH_PA_DELAY, &wcd939x->status_mask)) {
859 if (!wcd939x->comp1_enable)
863 clear_bit(HPH_PA_DELAY, &wcd939x->status_mask);
865 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
871 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_POST_PA,
873 if (wcd939x->ldoh)
885 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
902 enable_irq(wcd939x->ear_pdm_wd_int);
905 disable_irq_nosync(wcd939x->ear_pdm_wd_int);
915 wcd_clsh_ctrl_set_state(wcd939x->clsh_info, WCD_CLSH_EVENT_POST_PA,
929 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
935 switch (w->shift) {
969 dev_err(component->dev, "%s: Invalid DMIC Selection\n", __func__);
970 return -EINVAL;
979 if (w->shift == 2)
998 if (w->shift == 2)
1013 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1018 bank = sdw_slave_get_current_bank(wcd939x->sdw_priv[AIF1_CAP]->sdev);
1022 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1025 if (test_bit(WCD_ADC1, &wcd939x->status_mask))
1026 mode |= tx_mode_bit[wcd939x->tx_mode[WCD_ADC1]];
1027 if (test_bit(WCD_ADC2, &wcd939x->status_mask))
1028 mode |= tx_mode_bit[wcd939x->tx_mode[WCD_ADC2]];
1029 if (test_bit(WCD_ADC3, &wcd939x->status_mask))
1030 mode |= tx_mode_bit[wcd939x->tx_mode[WCD_ADC3]];
1031 if (test_bit(WCD_ADC4, &wcd939x->status_mask))
1032 mode |= tx_mode_bit[wcd939x->tx_mode[WCD_ADC4]];
1035 rate = wcd939x_get_clk_rate(ffs(mode) - 1);
1043 if (strnstr(w->name, "ADC", sizeof("ADC"))) {
1081 ret = -EINVAL;
1090 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1100 set_bit(w->shift, &wcd939x->status_mask);
1109 clear_bit(w->shift, &wcd939x->status_mask);
1148 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1159 wcd939x_tx_channel_config(component, w->shift, true);
1160 mode = wcd939x_get_adc_mode(wcd939x->tx_mode[w->shift]);
1162 dev_info(component->dev, "Invalid ADC mode\n");
1163 return -EINVAL;
1166 switch (w->shift) {
1211 wcd939x_tx_channel_config(component, w->shift, false);
1214 switch (w->shift) {
1268 int micb_index = micb_num - 1;
1285 dev_err(component->dev, "%s: Invalid micbias number: %d\n",
1287 return -EINVAL;
1292 wcd939x->pullup_ref[micb_index]++;
1293 if (wcd939x->pullup_ref[micb_index] == 1 &&
1294 wcd939x->micb_ref[micb_index] == 0)
1300 if (wcd939x->pullup_ref[micb_index] > 0)
1301 wcd939x->pullup_ref[micb_index]--;
1302 if (wcd939x->pullup_ref[micb_index] == 0 &&
1303 wcd939x->micb_ref[micb_index] == 0)
1309 wcd939x->micb_ref[micb_index]++;
1310 if (wcd939x->micb_ref[micb_index] == 1) {
1347 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
1351 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
1355 if (wcd939x->micb_ref[micb_index] > 0)
1356 wcd939x->micb_ref[micb_index]--;
1358 if (wcd939x->micb_ref[micb_index] == 0 &&
1359 wcd939x->pullup_ref[micb_index] > 0)
1363 else if (wcd939x->micb_ref[micb_index] == 0 &&
1364 wcd939x->pullup_ref[micb_index] == 0) {
1366 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
1373 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
1377 wcd_mbhc_event_notify(wcd939x->wcd_mbhc,
1389 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1390 int micb_num = w->shift;
1412 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1413 int micb_num = w->shift;
1438 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1439 int path = e->shift_l;
1441 ucontrol->value.enumerated.item[0] = wcd939x->tx_mode[path];
1451 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1452 int path = e->shift_l;
1454 if (wcd939x->tx_mode[path] == ucontrol->value.enumerated.item[0])
1457 wcd939x->tx_mode[path] = ucontrol->value.enumerated.item[0];
1470 ucontrol->value.integer.value[0] = wcd939x->hph_mode;
1482 mode_val = ucontrol->value.enumerated.item[0];
1484 if (mode_val == wcd939x->hph_mode)
1487 if (wcd939x->variant == CHIPID_WCD9390) {
1496 wcd939x->hph_mode = mode_val;
1510 wcd939x->hph_mode = mode_val;
1515 dev_dbg(component->dev, "%s: Invalid HPH Mode\n", __func__);
1516 return -EINVAL;
1522 struct soc_mixer_control *mc = (struct soc_mixer_control *)(kcontrol->private_value);
1526 if (mc->shift)
1527 ucontrol->value.integer.value[0] = wcd939x->comp2_enable ? 1 : 0;
1529 ucontrol->value.integer.value[0] = wcd939x->comp1_enable ? 1 : 0;
1537 struct soc_mixer_control *mc = (struct soc_mixer_control *)(kcontrol->private_value);
1540 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[AIF1_PB];
1541 bool value = !!ucontrol->value.integer.value[0];
1542 int portidx = wcd->ch_info[mc->reg].port_num;
1544 if (mc->shift)
1545 wcd939x->comp2_enable = value;
1547 wcd939x->comp1_enable = value;
1550 wcd939x_connect_port(wcd, portidx, mc->reg, true);
1552 wcd939x_connect_port(wcd, portidx, mc->reg, false);
1563 ucontrol->value.integer.value[0] = wcd939x->ldoh ? 1 : 0;
1574 if (wcd939x->ldoh == !!ucontrol->value.integer.value[0])
1577 wcd939x->ldoh = !!ucontrol->value.integer.value[0];
1791 struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1794 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[mixer->shift];
1795 unsigned int portidx = wcd->ch_info[mixer->reg].port_num;
1797 ucontrol->value.integer.value[0] = wcd->port_enable[portidx] ? 1 : 0;
1818 struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1821 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[mixer->shift];
1822 unsigned int portidx = wcd->ch_info[mixer->reg].port_num;
1824 wcd->port_enable[portidx] = !!ucontrol->value.integer.value[0];
1826 wcd939x_connect_port(wcd, portidx, mixer->reg, wcd->port_enable[portidx]);
1854 dev_err(component->dev, "%s: invalid number of buttons: %d\n",
1863 dev_dbg(component->dev, "%s: btn_high[%d]: %d, vth: %d\n",
1891 dev_dbg(component->dev, "%s: HS pull up current:%d\n",
1942 return -EINVAL;
1944 mutex_lock(&wcd939x->micb_lock);
1950 * to avoid slow micbias ramp-up or down enable pull-up
1951 * momentarily, change the micbias value and then re-enable
1959 req_vout_ctl = wcd_get_micb_vout_ctl_val(component->dev, req_volt);
1970 dev_dbg(component->dev, "%s: micb_num: %d, cur_mv: %d, req_mv: %d, micb_en: %d\n",
1994 mutex_unlock(&wcd939x->micb_lock);
2005 return -EINVAL;
2011 if (wcd939x->common.micb_mv[1] >= WCD_MBHC_THR_HS_MICB_MV)
2014 micb_mv = req_en ? WCD_MBHC_THR_HS_MICB_MV : wcd939x->common.micb_mv[1];
2068 dev_dbg(component->dev,
2075 denom = (x1 * d1) - (1 << (14 - zdet_param->noff));
2078 else if (x1 < wcd939x_mbhc_mincode_param[zdet_param->noff])
2081 dev_dbg(component->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%d(milliOhm)\n",
2104 WCD939X_ZDET_ANA_CTL_MAXV_CTL, zdet_param->ldo_ctl);
2106 zdet_param->btn5);
2108 zdet_param->btn6);
2110 zdet_param->btn7);
2112 WCD939X_ZDET_ANA_CTL_RANGE_CTL, zdet_param->noff);
2114 WCD939X_ZDET_RAMP_CTL_TIME_CTL, zdet_param->nshift);
2124 dev_dbg(component->dev, "%s: ramp for HPH_L, noff = %d\n",
2125 __func__, zdet_param->noff);
2139 dev_dbg(component->dev, "%s: ramp for HPH_R, noff = %d\n",
2140 __func__, zdet_param->noff);
2156 q1_cal = (10000 - ((q1 & GENMASK(6, 0)) * 10));
2167 struct wcd939x_priv *wcd939x = dev_get_drvdata(component->dev);
2186 /* For NO-jack, disable L_DET_EN before Z-det measurements */
2187 if (wcd939x->mbhc_cfg.hphl_swh)
2216 dev_dbg(component->dev, "%s: impedance on HPH_L = %d(ohms)\n",
2227 dev_dbg(component->dev, "%s: impedance on HPH_R = %d(ohms)\n",
2233 dev_dbg(component->dev,
2243 dev_dbg(component->dev,
2246 wcd_mbhc_set_hph_type(wcd939x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2265 z_diff1 = z1ls > z_mono ? z1ls - z_mono : z_mono - z1ls;
2266 z_diff2 = *zl > z1ls ? *zl - z1ls : z1ls - *zl;
2268 dev_dbg(component->dev, "%s: stereo plug type detected\n",
2270 wcd_mbhc_set_hph_type(wcd939x->wcd_mbhc, WCD_MBHC_HPH_STEREO);
2272 dev_dbg(component->dev, "%s: MONO plug type detected\n",
2274 wcd_mbhc_set_hph_type(wcd939x->wcd_mbhc, WCD_MBHC_HPH_MONO);
2292 /* For NO-jack, re-enable L_DET_EN after Z-det measurements */
2293 if (wcd939x->mbhc_cfg.hphl_swh)
2336 if (wcd939x->mbhc_cfg.moist_rref == R_OFF || wcd939x->typec_analog_mux) {
2343 if (!wcd939x->mbhc_cfg.hphl_swh) {
2344 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2352 WCD939X_CTL_2_M_RTH_CTL, wcd939x->mbhc_cfg.moist_rref);
2362 wcd939x->mbhc_cfg.moist_rref);
2373 if (wcd939x->mbhc_cfg.moist_rref == R_OFF || wcd939x->typec_analog_mux) {
2380 if (!wcd939x->mbhc_cfg.hphl_swh) {
2381 dev_dbg(component->dev, "%s: disable moisture detection for NC\n",
2438 ucontrol->value.integer.value[0] = wcd_mbhc_get_hph_type(wcd939x->wcd_mbhc);
2446 struct soc_mixer_control *mc = (struct soc_mixer_control *)(kcontrol->private_value);
2449 bool hphr = mc->shift;
2452 wcd_mbhc_get_impedance(wcd939x->wcd_mbhc, &zl, &zr);
2453 dev_dbg(component->dev, "%s: zl=%u(ohms), zr=%u(ohms)\n", __func__, zl, zr);
2454 ucontrol->value.integer.value[0] = hphr ? zr : zl;
2474 struct wcd_mbhc_intr *intr_ids = &wcd939x->intr_ids;
2476 intr_ids->mbhc_sw_intr = regmap_irq_get_virq(wcd939x->irq_chip,
2478 intr_ids->mbhc_btn_press_intr = regmap_irq_get_virq(wcd939x->irq_chip,
2480 intr_ids->mbhc_btn_release_intr = regmap_irq_get_virq(wcd939x->irq_chip,
2482 intr_ids->mbhc_hs_ins_intr = regmap_irq_get_virq(wcd939x->irq_chip,
2484 intr_ids->mbhc_hs_rem_intr = regmap_irq_get_virq(wcd939x->irq_chip,
2486 intr_ids->hph_left_ocp = regmap_irq_get_virq(wcd939x->irq_chip,
2488 intr_ids->hph_right_ocp = regmap_irq_get_virq(wcd939x->irq_chip,
2491 wcd939x->wcd_mbhc = wcd_mbhc_init(component, &mbhc_cb, intr_ids, wcd_mbhc_fields, true);
2492 if (IS_ERR(wcd939x->wcd_mbhc))
2493 return PTR_ERR(wcd939x->wcd_mbhc);
2507 wcd_mbhc_deinit(wcd939x->wcd_mbhc);
2699 SND_SOC_DAPM_SUPPLY("VA MIC BIAS1", SND_SOC_NOPM, MIC_BIAS_1, 0,
2703 SND_SOC_DAPM_SUPPLY("VA MIC BIAS2", SND_SOC_NOPM, MIC_BIAS_2, 0,
2707 SND_SOC_DAPM_SUPPLY("VA MIC BIAS3", SND_SOC_NOPM, MIC_BIAS_3, 0,
2711 SND_SOC_DAPM_SUPPLY("VA MIC BIAS4", SND_SOC_NOPM, MIC_BIAS_4, 0,
2887 regmap_update_bits(wcd939x->regmap, WCD939X_ANA_MICB1,
2888 WCD939X_MICB_VOUT_CTL, wcd939x->common.micb_vout[0]);
2889 regmap_update_bits(wcd939x->regmap, WCD939X_ANA_MICB2,
2890 WCD939X_MICB_VOUT_CTL, wcd939x->common.micb_vout[1]);
2891 regmap_update_bits(wcd939x->regmap, WCD939X_ANA_MICB3,
2892 WCD939X_MICB_VOUT_CTL, wcd939x->common.micb_vout[2]);
2893 regmap_update_bits(wcd939x->regmap, WCD939X_ANA_MICB4,
2894 WCD939X_MICB_VOUT_CTL, wcd939x->common.micb_vout[3]);
2932 * \-handle_nested_irq(0)
2933 * \- regmap_irq_thread()
2934 * \- handle_nested_irq(i)
2956 wcd->virq = irq_domain_create_linear(NULL, 1, &wcd_domain_ops, NULL);
2957 if (!(wcd->virq)) {
2959 return -EINVAL;
2962 return devm_regmap_add_irq_chip(dev, wcd->regmap,
2963 irq_create_mapping(wcd->virq, 0),
2965 &wcd->irq_chip);
2971 struct sdw_slave *tx_sdw_dev = wcd939x->tx_sdw_dev;
2972 struct device *dev = component->dev;
2976 time_left = wait_for_completion_timeout(&tx_sdw_dev->initialization_complete,
2980 return -ETIMEDOUT;
2983 snd_soc_component_init_regmap(component, wcd939x->regmap);
2989 wcd939x->variant = snd_soc_component_read_field(component,
2993 wcd939x->clsh_info = wcd_clsh_ctrl_alloc(component, WCD939X);
2994 if (IS_ERR(wcd939x->clsh_info)) {
2996 return PTR_ERR(wcd939x->clsh_info);
3003 regmap_write(wcd939x->regmap,
3009 wcd939x->hphr_pdm_wd_int = regmap_irq_get_virq(wcd939x->irq_chip,
3011 wcd939x->hphl_pdm_wd_int = regmap_irq_get_virq(wcd939x->irq_chip,
3013 wcd939x->ear_pdm_wd_int = regmap_irq_get_virq(wcd939x->irq_chip,
3016 ret = request_threaded_irq(wcd939x->hphr_pdm_wd_int, NULL, wcd939x_wd_handle_irq,
3024 ret = request_threaded_irq(wcd939x->hphl_pdm_wd_int, NULL, wcd939x_wd_handle_irq,
3032 ret = request_threaded_irq(wcd939x->ear_pdm_wd_int, NULL, wcd939x_wd_handle_irq,
3041 disable_irq_nosync(wcd939x->hphr_pdm_wd_int);
3042 disable_irq_nosync(wcd939x->hphl_pdm_wd_int);
3043 disable_irq_nosync(wcd939x->ear_pdm_wd_int);
3045 switch (wcd939x->variant) {
3050 dev_err(component->dev,
3052 __func__, wcd939x->variant);
3060 dev_err(component->dev,
3062 __func__, wcd939x->variant);
3072 dev_err(component->dev, "mbhc initialization failed\n");
3079 free_irq(wcd939x->ear_pdm_wd_int, wcd939x);
3081 free_irq(wcd939x->hphl_pdm_wd_int, wcd939x);
3083 free_irq(wcd939x->hphr_pdm_wd_int, wcd939x);
3085 wcd_clsh_ctrl_free(wcd939x->clsh_info);
3096 free_irq(wcd939x->ear_pdm_wd_int, wcd939x);
3097 free_irq(wcd939x->hphl_pdm_wd_int, wcd939x);
3098 free_irq(wcd939x->hphr_pdm_wd_int, wcd939x);
3100 wcd_clsh_ctrl_free(wcd939x->clsh_info);
3106 struct wcd939x_priv *wcd = dev_get_drvdata(comp->dev);
3109 return wcd_mbhc_start(wcd->wcd_mbhc, &wcd->mbhc_cfg, jack);
3111 wcd_mbhc_stop(wcd->wcd_mbhc);
3131 /* Get USB-C plug orientation to provide swap event for MBHC */
3137 wcd939x->typec_orientation = orientation;
3146 unsigned int previous_mode = wcd939x->typec_mode;
3148 if (!wcd939x->wcd_mbhc)
3149 return -EINVAL;
3151 if (wcd939x->typec_mode != state->mode) {
3152 wcd939x->typec_mode = state->mode;
3154 if (wcd939x->typec_mode == TYPEC_MODE_AUDIO)
3155 return wcd_mbhc_typec_report_plug(wcd939x->wcd_mbhc);
3157 return wcd_mbhc_typec_report_unplug(wcd939x->wcd_mbhc);
3169 if (!wcd939x->typec_analog_mux || !wcd939x->typec_switch)
3173 typec_switch_set(wcd939x->typec_switch,
3174 wcd939x->typec_orientation == TYPEC_ORIENTATION_REVERSE ?
3183 struct wcd_mbhc_config *cfg = &wcd939x->mbhc_cfg;
3189 wcd939x->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
3190 if (IS_ERR(wcd939x->reset_gpio))
3191 return dev_err_probe(dev, PTR_ERR(wcd939x->reset_gpio),
3199 ret = wcd_dt_parse_micbias_info(&wcd939x->common);
3203 cfg->mbhc_micbias = MIC_BIAS_2;
3204 cfg->anc_micbias = MIC_BIAS_2;
3205 cfg->v_hs_max = WCD_MBHC_HS_V_MAX;
3206 cfg->num_btn = WCD939X_MBHC_MAX_BUTTONS;
3207 cfg->micb_mv = wcd939x->common.micb_mv[1];
3208 cfg->linein_th = 5000;
3209 cfg->hs_thr = 1700;
3210 cfg->hph_thr = 50;
3219 np = of_graph_get_remote_node(dev->of_node, 0, 0);
3221 wcd939x->typec_analog_mux = true;
3222 cfg->typec_analog_mux = true;
3223 cfg->swap_gnd_mic = wcd939x_swap_gnd_mic;
3232 gpiod_set_value(wcd939x->reset_gpio, 1);
3235 gpiod_set_value(wcd939x->reset_gpio, 0);
3244 struct snd_soc_dai *dai)
3246 struct wcd939x_priv *wcd939x = dev_get_drvdata(dai->dev);
3247 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[dai->id];
3249 return wcd939x_sdw_hw_params(wcd, substream, params, dai);
3253 struct snd_soc_dai *dai)
3255 struct wcd939x_priv *wcd939x = dev_get_drvdata(dai->dev);
3256 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[dai->id];
3258 return wcd939x_sdw_free(wcd, substream, dai);
3261 static int wcd939x_codec_set_sdw_stream(struct snd_soc_dai *dai,
3264 struct wcd939x_priv *wcd939x = dev_get_drvdata(dai->dev);
3265 struct wcd939x_sdw_priv *wcd = wcd939x->sdw_priv[dai->id];
3267 return wcd939x_sdw_set_sdw_stream(wcd, dai, stream, direction);
3278 .name = "wcd939x-sdw-rx",
3291 .name = "wcd939x-sdw-tx",
3313 * Get USBSS type-c switch to send gnd/mic swap events
3317 if (wcd939x->typec_analog_mux) {
3318 wcd939x->typec_switch = fwnode_typec_switch_get(dev->fwnode);
3319 if (IS_ERR(wcd939x->typec_switch))
3320 return dev_err_probe(dev, PTR_ERR(wcd939x->typec_switch),
3321 "failed to acquire orientation-switch\n");
3332 wcd939x->rxdev = of_sdw_find_device_by_node(wcd939x->rxnode);
3333 if (!wcd939x->rxdev) {
3335 ret = -EINVAL;
3338 wcd939x->sdw_priv[AIF1_PB] = dev_get_drvdata(wcd939x->rxdev);
3339 wcd939x->sdw_priv[AIF1_PB]->wcd939x = wcd939x;
3341 wcd939x->txdev = of_sdw_find_device_by_node(wcd939x->txnode);
3342 if (!wcd939x->txdev) {
3344 ret = -EINVAL;
3347 wcd939x->sdw_priv[AIF1_CAP] = dev_get_drvdata(wcd939x->txdev);
3348 wcd939x->sdw_priv[AIF1_CAP]->wcd939x = wcd939x;
3349 wcd939x->tx_sdw_dev = dev_to_sdw_dev(wcd939x->txdev);
3353 * explicitly add the dependency link
3355 if (!device_link_add(wcd939x->rxdev, wcd939x->txdev, DL_FLAG_STATELESS |
3358 ret = -EINVAL;
3362 if (!device_link_add(dev, wcd939x->txdev, DL_FLAG_STATELESS |
3365 ret = -EINVAL;
3369 if (!device_link_add(dev, wcd939x->rxdev, DL_FLAG_STATELESS |
3372 ret = -EINVAL;
3377 wcd939x->regmap = wcd939x->sdw_priv[AIF1_CAP]->regmap;
3378 if (!wcd939x->regmap) {
3380 ret = -ENODEV;
3390 wcd939x->sdw_priv[AIF1_PB]->slave_irq = wcd939x->virq;
3391 wcd939x->sdw_priv[AIF1_CAP]->slave_irq = wcd939x->virq;
3396 regmap_read(wcd939x->regmap, WCD939X_DIGITAL_CHIP_ID1, &id1);
3397 regmap_read(wcd939x->regmap, WCD939X_EAR_STATUS_REG_1, &status1);
3417 device_link_remove(dev, wcd939x->rxdev);
3419 device_link_remove(dev, wcd939x->txdev);
3421 device_link_remove(wcd939x->rxdev, wcd939x->txdev);
3423 put_device(wcd939x->txdev);
3425 put_device(wcd939x->rxdev);
3430 if (wcd939x->typec_analog_mux)
3431 typec_switch_put(wcd939x->typec_switch);
3442 device_link_remove(dev, wcd939x->txdev);
3443 device_link_remove(dev, wcd939x->rxdev);
3444 device_link_remove(wcd939x->rxdev, wcd939x->txdev);
3445 put_device(wcd939x->txdev);
3446 put_device(wcd939x->rxdev);
3490 if (!wcd939x->typec_analog_mux)
3521 struct device_node *np = dev->of_node;
3523 wcd939x->rxnode = of_parse_phandle(np, "qcom,rx-device", 0);
3524 if (!wcd939x->rxnode) {
3525 dev_err(dev, "%s: Rx-device node not defined\n", __func__);
3526 return -ENODEV;
3529 of_node_get(wcd939x->rxnode);
3531 component_compare_of, wcd939x->rxnode);
3533 wcd939x->txnode = of_parse_phandle(np, "qcom,tx-device", 0);
3534 if (!wcd939x->txnode) {
3535 dev_err(dev, "%s: Tx-device node not defined\n", __func__);
3536 return -ENODEV;
3538 of_node_get(wcd939x->txnode);
3540 component_compare_of, wcd939x->txnode);
3548 struct device *dev = &pdev->dev;
3554 return -ENOMEM;
3557 mutex_init(&wcd939x->micb_lock);
3558 wcd939x->common.dev = dev;
3559 wcd939x->common.max_bias = 4;
3564 return -EINVAL;
3593 struct device *dev = &pdev->dev;
3604 { .compatible = "qcom,wcd9390-codec" },
3605 { .compatible = "qcom,wcd9395-codec" },