Merge tag 'drm-msm-fixes-2022-01-25' of https://gitlab.freedesktop.org/drm/msm into...

[platform/kernel/linux-starfive.git] / sound / soc / codecs / wcd-mbhc-v2.c

diff --git a/sound/soc/codecs/wcd-mbhc-v2.c b/sound/soc/codecs/wcd-mbhc-v2.c
index 405128c..7488a15 100644 (file)
--- a/sound/soc/codecs/wcd-mbhc-v2.c
+++ b/sound/soc/codecs/wcd-mbhc-v2.c
@@ -1022,6 +1022,52 @@ static int wcd_mbhc_get_plug_from_adc(struct wcd_mbhc *mbhc, int adc_result)
        return plug_type;
 }
 
+static int wcd_mbhc_get_spl_hs_thres(struct wcd_mbhc *mbhc)
+{
+       int hs_threshold, micbias_mv;
+
+       micbias_mv = wcd_mbhc_get_micbias(mbhc);
+       if (mbhc->cfg->hs_thr && mbhc->cfg->micb_mv != WCD_MBHC_ADC_MICBIAS_MV) {
+               if (mbhc->cfg->micb_mv == micbias_mv)
+                       hs_threshold = mbhc->cfg->hs_thr;
+               else
+                       hs_threshold = (mbhc->cfg->hs_thr * micbias_mv) / mbhc->cfg->micb_mv;
+       } else {
+               hs_threshold = ((WCD_MBHC_ADC_HS_THRESHOLD_MV * micbias_mv) /
+                                                       WCD_MBHC_ADC_MICBIAS_MV);
+       }
+       return hs_threshold;
+}
+
+static bool wcd_mbhc_check_for_spl_headset(struct wcd_mbhc *mbhc)
+{
+       bool is_spl_hs = false;
+       int output_mv, hs_threshold, hph_threshold;
+
+       if (!mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic)
+               return false;
+
+       /* Bump up MIC_BIAS2 to 2.7V */
+       mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(mbhc->component, MIC_BIAS_2, true);
+       usleep_range(10000, 10100);
+
+       output_mv = wcd_measure_adc_once(mbhc, MUX_CTL_IN2P);
+       hs_threshold = wcd_mbhc_get_spl_hs_thres(mbhc);
+       hph_threshold = wcd_mbhc_adc_get_hph_thres(mbhc);
+
+       if (!(output_mv > hs_threshold || output_mv < hph_threshold))
+               is_spl_hs = true;
+
+       /* Back MIC_BIAS2 to 1.8v if the type is not special headset */
+       if (!is_spl_hs) {
+               mbhc->mbhc_cb->mbhc_micb_ctrl_thr_mic(mbhc->component, MIC_BIAS_2, false);
+               /* Add 10ms delay for micbias to settle */
+               usleep_range(10000, 10100);
+       }
+
+       return is_spl_hs;
+}
+
 static void wcd_correct_swch_plug(struct work_struct *work)
 {
        struct wcd_mbhc *mbhc;
@@ -1029,12 +1075,14 @@ static void wcd_correct_swch_plug(struct work_struct *work)
        enum wcd_mbhc_plug_type plug_type = MBHC_PLUG_TYPE_INVALID;
        unsigned long timeout;
        int pt_gnd_mic_swap_cnt = 0;
-       int output_mv, cross_conn, hs_threshold, try = 0;
+       int output_mv, cross_conn, hs_threshold, try = 0, micbias_mv;
+       bool is_spl_hs = false;
        bool is_pa_on;
 
        mbhc = container_of(work, struct wcd_mbhc, correct_plug_swch);
        component = mbhc->component;
 
+       micbias_mv = wcd_mbhc_get_micbias(mbhc);
        hs_threshold = wcd_mbhc_adc_get_hs_thres(mbhc);
 
        /* Mask ADC COMPLETE interrupt */
@@ -1097,6 +1145,16 @@ correct_plug_type:
                plug_type = wcd_mbhc_get_plug_from_adc(mbhc, output_mv);
                is_pa_on = wcd_mbhc_read_field(mbhc, WCD_MBHC_HPH_PA_EN);
 
+               if (output_mv > hs_threshold && !is_spl_hs) {
+                       is_spl_hs = wcd_mbhc_check_for_spl_headset(mbhc);
+                       output_mv = wcd_measure_adc_once(mbhc, MUX_CTL_IN2P);
+
+                       if (is_spl_hs) {
+                               hs_threshold *= wcd_mbhc_get_micbias(mbhc);
+                               hs_threshold /= micbias_mv;
+                       }
+               }
+
                if ((output_mv <= hs_threshold) && !is_pa_on) {
                        /* Check for cross connection*/
                        cross_conn = wcd_check_cross_conn(mbhc);
@@ -1122,14 +1180,19 @@ correct_plug_type:
                        }
                }
 
-               if (output_mv > hs_threshold) /* cable is extension cable */
+               /* cable is extension cable */
+               if (output_mv > hs_threshold || mbhc->force_linein)
                        plug_type = MBHC_PLUG_TYPE_HIGH_HPH;
        }
 
        wcd_mbhc_bcs_enable(mbhc, plug_type, true);
 
-       if (plug_type == MBHC_PLUG_TYPE_HIGH_HPH)
-               wcd_mbhc_write_field(mbhc, WCD_MBHC_ELECT_ISRC_EN, 1);
+       if (plug_type == MBHC_PLUG_TYPE_HIGH_HPH) {
+               if (is_spl_hs)
+                       plug_type = MBHC_PLUG_TYPE_HEADSET;
+               else
+                       wcd_mbhc_write_field(mbhc, WCD_MBHC_ELECT_ISRC_EN, 1);
+       }
 
        wcd_mbhc_write_field(mbhc, WCD_MBHC_ADC_MODE, 0);
        wcd_mbhc_write_field(mbhc, WCD_MBHC_ADC_EN, 0);
@@ -1176,7 +1239,6 @@ static irqreturn_t wcd_mbhc_adc_hs_rem_irq(int irq, void *data)
        struct wcd_mbhc *mbhc = data;
        unsigned long timeout;
        int adc_threshold, output_mv, retry = 0;
-       bool hphpa_on = false;
 
        mutex_lock(&mbhc->lock);
        timeout = jiffies + msecs_to_jiffies(WCD_FAKE_REMOVAL_MIN_PERIOD_MS);
@@ -1210,10 +1272,6 @@ static irqreturn_t wcd_mbhc_adc_hs_rem_irq(int irq, void *data)
        wcd_mbhc_elec_hs_report_unplug(mbhc);
        wcd_mbhc_write_field(mbhc, WCD_MBHC_BTN_ISRC_CTL, 0);
 
-       if (hphpa_on) {
-               hphpa_on = false;
-               wcd_mbhc_write_field(mbhc, WCD_MBHC_HPH_PA_EN, 3);
-       }
 exit:
        mutex_unlock(&mbhc->lock);
        return IRQ_HANDLED;