Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // rt711-sdca.c -- rt711 SDCA ALSA SoC audio driver
0004 //
0005 // Copyright(c) 2021 Realtek Semiconductor Corp.
0006 //
0007 //
0008 
0009 #include <linux/module.h>
0010 #include <linux/moduleparam.h>
0011 #include <linux/kernel.h>
0012 #include <linux/init.h>
0013 #include <linux/delay.h>
0014 #include <linux/pm_runtime.h>
0015 #include <linux/soundwire/sdw_registers.h>
0016 #include <linux/slab.h>
0017 #include <linux/bitops.h>
0018 #include <sound/core.h>
0019 #include <sound/pcm.h>
0020 #include <sound/pcm_params.h>
0021 #include <sound/soc-dapm.h>
0022 #include <sound/initval.h>
0023 #include <sound/tlv.h>
0024 #include <sound/jack.h>
0025 
0026 #include "rt711-sdca.h"
0027 
0028 static int rt711_sdca_index_write(struct rt711_sdca_priv *rt711,
0029         unsigned int nid, unsigned int reg, unsigned int value)
0030 {
0031     int ret;
0032     struct regmap *regmap = rt711->mbq_regmap;
0033     unsigned int addr = (nid << 20) | reg;
0034 
0035     ret = regmap_write(regmap, addr, value);
0036     if (ret < 0)
0037         dev_err(&rt711->slave->dev,
0038             "Failed to set private value: %06x <= %04x ret=%d\n",
0039             addr, value, ret);
0040 
0041     return ret;
0042 }
0043 
0044 static int rt711_sdca_index_read(struct rt711_sdca_priv *rt711,
0045         unsigned int nid, unsigned int reg, unsigned int *value)
0046 {
0047     int ret;
0048     struct regmap *regmap = rt711->mbq_regmap;
0049     unsigned int addr = (nid << 20) | reg;
0050 
0051     ret = regmap_read(regmap, addr, value);
0052     if (ret < 0)
0053         dev_err(&rt711->slave->dev,
0054             "Failed to get private value: %06x => %04x ret=%d\n",
0055             addr, *value, ret);
0056 
0057     return ret;
0058 }
0059 
0060 static int rt711_sdca_index_update_bits(struct rt711_sdca_priv *rt711,
0061     unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val)
0062 {
0063     unsigned int tmp;
0064     int ret;
0065 
0066     ret = rt711_sdca_index_read(rt711, nid, reg, &tmp);
0067     if (ret < 0)
0068         return ret;
0069 
0070     set_mask_bits(&tmp, mask, val);
0071     return rt711_sdca_index_write(rt711, nid, reg, tmp);
0072 }
0073 
0074 static void rt711_sdca_reset(struct rt711_sdca_priv *rt711)
0075 {
0076     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0077         RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET,
0078         RT711_HIDDEN_REG_SW_RESET);
0079     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0080         RT711_HDA_LEGACY_RESET_CTL, 0x1, 0x1);
0081 }
0082 
0083 static int rt711_sdca_calibration(struct rt711_sdca_priv *rt711)
0084 {
0085     unsigned int val, loop_rc = 0, loop_dc = 0;
0086     struct device *dev;
0087     struct regmap *regmap = rt711->regmap;
0088     int chk_cnt = 100;
0089     int ret = 0;
0090 
0091     mutex_lock(&rt711->calibrate_mutex);
0092     dev = regmap_get_device(regmap);
0093 
0094     regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
0095     /* RC calibration */
0096     if (!(val & 0x40))
0097         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
0098             RT711_MISC_POWER_CTL0, 0x0010, 0x0010);
0099 
0100     for (loop_rc = 0; loop_rc < chk_cnt && !(val & 0x40); loop_rc++) {
0101         usleep_range(10000, 11000);
0102         ret = regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
0103         if (ret < 0)
0104             goto _cali_fail_;
0105     }
0106     if (loop_rc == chk_cnt)
0107         dev_err(dev, "%s, RC calibration time-out!\n", __func__);
0108 
0109     /* HP calibration by manual mode setting */
0110     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0111         RT711_FSM_CTL, 0x2000, 0x2000);
0112 
0113     /* Calibration manual mode */
0114     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0115         RT711_FSM_CTL, 0xf, RT711_CALI_CTL);
0116 
0117     /* reset HP calibration */
0118     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
0119         RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST, 0x00);
0120     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
0121         RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST,
0122         RT711_DAC_DC_FORCE_CALI_RST);
0123 
0124     /* cal_clk_en_reg */
0125     if (rt711->hw_ver == RT711_VER_VD0)
0126         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
0127             RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_CLK_EN,
0128             RT711_DAC_DC_CALI_CLK_EN);
0129 
0130     /* trigger */
0131     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
0132         RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER,
0133         RT711_DAC_DC_CALI_TRIGGER);
0134 
0135     /* wait for calibration process */
0136     rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
0137         RT711_DAC_DC_CALI_CTL1, &val);
0138 
0139     for (loop_dc = 0; loop_dc < chk_cnt &&
0140         (val & RT711_DAC_DC_CALI_TRIGGER); loop_dc++) {
0141         usleep_range(10000, 11000);
0142         ret = rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
0143             RT711_DAC_DC_CALI_CTL1, &val);
0144         if (ret < 0)
0145             goto _cali_fail_;
0146     }
0147     if (loop_dc == chk_cnt)
0148         dev_err(dev, "%s, calibration time-out!\n", __func__);
0149 
0150     if (loop_dc == chk_cnt || loop_rc == chk_cnt)
0151         ret = -ETIMEDOUT;
0152 
0153 _cali_fail_:
0154     /* enable impedance sense */
0155     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0156         RT711_FSM_CTL, RT711_FSM_IMP_EN, RT711_FSM_IMP_EN);
0157 
0158     /* release HP-JD and trigger FSM */
0159     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
0160         RT711_DIGITAL_MISC_CTRL4, 0x201b);
0161 
0162     mutex_unlock(&rt711->calibrate_mutex);
0163     dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
0164     return ret;
0165 }
0166 
0167 static unsigned int rt711_sdca_button_detect(struct rt711_sdca_priv *rt711)
0168 {
0169     unsigned int btn_type = 0, offset, idx, val, owner;
0170     int ret;
0171     unsigned char buf[3];
0172 
0173     /* get current UMP message owner */
0174     ret = regmap_read(rt711->regmap,
0175         SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0),
0176         &owner);
0177     if (ret < 0)
0178         return 0;
0179 
0180     /* if owner is device then there is no button event from device */
0181     if (owner == 1)
0182         return 0;
0183 
0184     /* read UMP message offset */
0185     ret = regmap_read(rt711->regmap,
0186         SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
0187         &offset);
0188     if (ret < 0)
0189         goto _end_btn_det_;
0190 
0191     for (idx = 0; idx < sizeof(buf); idx++) {
0192         ret = regmap_read(rt711->regmap,
0193             RT711_BUF_ADDR_HID1 + offset + idx, &val);
0194         if (ret < 0)
0195             goto _end_btn_det_;
0196         buf[idx] = val & 0xff;
0197     }
0198 
0199     if (buf[0] == 0x11) {
0200         switch (buf[1] & 0xf0) {
0201         case 0x10:
0202             btn_type |= SND_JACK_BTN_2;
0203             break;
0204         case 0x20:
0205             btn_type |= SND_JACK_BTN_3;
0206             break;
0207         case 0x40:
0208             btn_type |= SND_JACK_BTN_0;
0209             break;
0210         case 0x80:
0211             btn_type |= SND_JACK_BTN_1;
0212             break;
0213         }
0214         switch (buf[2]) {
0215         case 0x01:
0216         case 0x10:
0217             btn_type |= SND_JACK_BTN_2;
0218             break;
0219         case 0x02:
0220         case 0x20:
0221             btn_type |= SND_JACK_BTN_3;
0222             break;
0223         case 0x04:
0224         case 0x40:
0225             btn_type |= SND_JACK_BTN_0;
0226             break;
0227         case 0x08:
0228         case 0x80:
0229             btn_type |= SND_JACK_BTN_1;
0230             break;
0231         }
0232     }
0233 
0234 _end_btn_det_:
0235     /* Host is owner, so set back to device */
0236     if (owner == 0)
0237         /* set owner to device */
0238         regmap_write(rt711->regmap,
0239             SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01,
0240                 RT711_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01);
0241 
0242     return btn_type;
0243 }
0244 
0245 static int rt711_sdca_headset_detect(struct rt711_sdca_priv *rt711)
0246 {
0247     unsigned int det_mode;
0248     int ret;
0249 
0250     /* get detected_mode */
0251     ret = regmap_read(rt711->regmap,
0252         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
0253         &det_mode);
0254     if (ret < 0)
0255         goto io_error;
0256 
0257     switch (det_mode) {
0258     case 0x00:
0259         rt711->jack_type = 0;
0260         break;
0261     case 0x03:
0262         rt711->jack_type = SND_JACK_HEADPHONE;
0263         break;
0264     case 0x05:
0265         rt711->jack_type = SND_JACK_HEADSET;
0266         break;
0267     }
0268 
0269     /* write selected_mode */
0270     if (det_mode) {
0271         ret = regmap_write(rt711->regmap,
0272             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_SELECTED_MODE, 0),
0273             det_mode);
0274         if (ret < 0)
0275             goto io_error;
0276     }
0277 
0278     dev_dbg(&rt711->slave->dev,
0279         "%s, detected_mode=0x%x\n", __func__, det_mode);
0280 
0281     return 0;
0282 
0283 io_error:
0284     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0285     return ret;
0286 }
0287 
0288 static void rt711_sdca_jack_detect_handler(struct work_struct *work)
0289 {
0290     struct rt711_sdca_priv *rt711 =
0291         container_of(work, struct rt711_sdca_priv, jack_detect_work.work);
0292     int btn_type = 0, ret;
0293 
0294     if (!rt711->hs_jack)
0295         return;
0296 
0297     if (!rt711->component->card || !rt711->component->card->instantiated)
0298         return;
0299 
0300     /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */
0301     if (rt711->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
0302         ret = rt711_sdca_headset_detect(rt711);
0303         if (ret < 0)
0304             return;
0305     }
0306 
0307     /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
0308     if (rt711->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
0309         btn_type = rt711_sdca_button_detect(rt711);
0310 
0311     if (rt711->jack_type == 0)
0312         btn_type = 0;
0313 
0314     dev_dbg(&rt711->slave->dev,
0315         "in %s, jack_type=0x%x\n", __func__, rt711->jack_type);
0316     dev_dbg(&rt711->slave->dev,
0317         "in %s, btn_type=0x%x\n", __func__, btn_type);
0318     dev_dbg(&rt711->slave->dev,
0319         "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
0320         rt711->scp_sdca_stat1, rt711->scp_sdca_stat2);
0321 
0322     snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
0323             SND_JACK_HEADSET |
0324             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0325             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0326 
0327     if (btn_type) {
0328         /* button released */
0329         snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
0330             SND_JACK_HEADSET |
0331             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0332             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0333 
0334         mod_delayed_work(system_power_efficient_wq,
0335             &rt711->jack_btn_check_work, msecs_to_jiffies(200));
0336     }
0337 }
0338 
0339 static void rt711_sdca_btn_check_handler(struct work_struct *work)
0340 {
0341     struct rt711_sdca_priv *rt711 =
0342         container_of(work, struct rt711_sdca_priv, jack_btn_check_work.work);
0343     int btn_type = 0, ret, idx;
0344     unsigned int det_mode, offset, val;
0345     unsigned char buf[3];
0346 
0347     ret = regmap_read(rt711->regmap,
0348         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
0349         &det_mode);
0350     if (ret < 0)
0351         goto io_error;
0352 
0353     /* pin attached */
0354     if (det_mode) {
0355         /* read UMP message offset */
0356         ret = regmap_read(rt711->regmap,
0357             SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
0358             &offset);
0359         if (ret < 0)
0360             goto io_error;
0361 
0362         for (idx = 0; idx < sizeof(buf); idx++) {
0363             ret = regmap_read(rt711->regmap,
0364                 RT711_BUF_ADDR_HID1 + offset + idx, &val);
0365             if (ret < 0)
0366                 goto io_error;
0367             buf[idx] = val & 0xff;
0368         }
0369 
0370         if (buf[0] == 0x11) {
0371             switch (buf[1] & 0xf0) {
0372             case 0x10:
0373                 btn_type |= SND_JACK_BTN_2;
0374                 break;
0375             case 0x20:
0376                 btn_type |= SND_JACK_BTN_3;
0377                 break;
0378             case 0x40:
0379                 btn_type |= SND_JACK_BTN_0;
0380                 break;
0381             case 0x80:
0382                 btn_type |= SND_JACK_BTN_1;
0383                 break;
0384             }
0385             switch (buf[2]) {
0386             case 0x01:
0387             case 0x10:
0388                 btn_type |= SND_JACK_BTN_2;
0389                 break;
0390             case 0x02:
0391             case 0x20:
0392                 btn_type |= SND_JACK_BTN_3;
0393                 break;
0394             case 0x04:
0395             case 0x40:
0396                 btn_type |= SND_JACK_BTN_0;
0397                 break;
0398             case 0x08:
0399             case 0x80:
0400                 btn_type |= SND_JACK_BTN_1;
0401                 break;
0402             }
0403         }
0404     } else
0405         rt711->jack_type = 0;
0406 
0407     dev_dbg(&rt711->slave->dev, "%s, btn_type=0x%x\n",  __func__, btn_type);
0408     snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
0409             SND_JACK_HEADSET |
0410             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0411             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0412 
0413     if (btn_type) {
0414         /* button released */
0415         snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
0416             SND_JACK_HEADSET |
0417             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0418             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0419 
0420         mod_delayed_work(system_power_efficient_wq,
0421             &rt711->jack_btn_check_work, msecs_to_jiffies(200));
0422     }
0423 
0424     return;
0425 
0426 io_error:
0427     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0428 }
0429 
0430 static void rt711_sdca_jack_init(struct rt711_sdca_priv *rt711)
0431 {
0432     mutex_lock(&rt711->calibrate_mutex);
0433 
0434     if (rt711->hs_jack) {
0435         /* Enable HID1 event & set button RTC mode */
0436         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0437             RT711_PUSH_BTN_INT_CTL6, 0x80f0, 0x8000);
0438         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0439             RT711_PUSH_BTN_INT_CTL2, 0x11dd, 0x11dd);
0440         rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
0441             RT711_PUSH_BTN_INT_CTL7, 0xffff);
0442         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0443             RT711_PUSH_BTN_INT_CTL9, 0xf000, 0x0000);
0444 
0445         /* GE_mode_change_event_en & Hid1_push_button_event_en */
0446         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0447             RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0c00);
0448 
0449         switch (rt711->jd_src) {
0450         case RT711_JD1:
0451             /* default settings was already for JD1 */
0452             break;
0453         case RT711_JD2:
0454             rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0455                 RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL,
0456                 RT711_JD2_DIGITAL_MODE_SEL);
0457             rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0458                 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2,
0459                 RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2);
0460             rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
0461                 RT711_CC_DET1,
0462                 RT711_HP_JD_FINAL_RESULT_CTL_JD12,
0463                 RT711_HP_JD_FINAL_RESULT_CTL_JD12);
0464             break;
0465         default:
0466             dev_warn(rt711->component->dev, "Wrong JD source\n");
0467             break;
0468         }
0469 
0470         /* set SCP_SDCA_IntMask1[0]=1 */
0471         sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
0472         /* set SCP_SDCA_IntMask2[0]=1 */
0473         sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
0474         dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__);
0475     } else {
0476         /* disable HID 1/2 event */
0477         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0478             RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0000);
0479 
0480         dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__);
0481     }
0482 
0483     mutex_unlock(&rt711->calibrate_mutex);
0484 }
0485 
0486 static int rt711_sdca_set_jack_detect(struct snd_soc_component *component,
0487     struct snd_soc_jack *hs_jack, void *data)
0488 {
0489     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0490     int ret;
0491 
0492     rt711->hs_jack = hs_jack;
0493 
0494     ret = pm_runtime_resume_and_get(component->dev);
0495     if (ret < 0) {
0496         if (ret != -EACCES) {
0497             dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
0498             return ret;
0499         }
0500 
0501         /* pm_runtime not enabled yet */
0502         dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
0503         return 0;
0504     }
0505 
0506     rt711_sdca_jack_init(rt711);
0507 
0508     pm_runtime_mark_last_busy(component->dev);
0509     pm_runtime_put_autosuspend(component->dev);
0510 
0511     return 0;
0512 }
0513 
0514 /* For SDCA control DAC/ADC Gain */
0515 static int rt711_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
0516         struct snd_ctl_elem_value *ucontrol)
0517 {
0518     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0519     struct soc_mixer_control *mc =
0520         (struct soc_mixer_control *)kcontrol->private_value;
0521     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0522     unsigned int read_l, read_r, gain_l_val, gain_r_val;
0523     unsigned int i, adc_vol_flag = 0, changed = 0;
0524     unsigned int lvalue, rvalue;
0525 
0526     if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
0527         strstr(ucontrol->id.name, "FU0F Capture Volume"))
0528         adc_vol_flag = 1;
0529 
0530     regmap_read(rt711->mbq_regmap, mc->reg, &lvalue);
0531     regmap_read(rt711->mbq_regmap, mc->rreg, &rvalue);
0532 
0533     /* control value to 2's complement value */
0534     /* L Channel */
0535     gain_l_val = ucontrol->value.integer.value[0];
0536     if (gain_l_val > mc->max)
0537         gain_l_val = mc->max;
0538     read_l = gain_l_val;
0539 
0540     if (mc->shift == 8) /* boost gain */
0541         gain_l_val = (gain_l_val * 10) << mc->shift;
0542     else { /* ADC/DAC gain */
0543         if (adc_vol_flag && gain_l_val > mc->shift)
0544             gain_l_val = (gain_l_val - mc->shift) * 75;
0545         else
0546             gain_l_val = (mc->shift - gain_l_val) * 75;
0547         gain_l_val <<= 8;
0548         gain_l_val /= 100;
0549         if (!(adc_vol_flag && read_l > mc->shift)) {
0550             gain_l_val = ~gain_l_val;
0551             gain_l_val += 1;
0552         }
0553         gain_l_val &= 0xffff;
0554     }
0555 
0556     /* R Channel */
0557     gain_r_val = ucontrol->value.integer.value[1];
0558     if (gain_r_val > mc->max)
0559         gain_r_val = mc->max;
0560     read_r = gain_r_val;
0561 
0562     if (mc->shift == 8) /* boost gain */
0563         gain_r_val = (gain_r_val * 10) << mc->shift;
0564     else { /* ADC/DAC gain */
0565         if (adc_vol_flag && gain_r_val > mc->shift)
0566             gain_r_val = (gain_r_val - mc->shift) * 75;
0567         else
0568             gain_r_val = (mc->shift - gain_r_val) * 75;
0569         gain_r_val <<= 8;
0570         gain_r_val /= 100;
0571         if (!(adc_vol_flag && read_r > mc->shift)) {
0572             gain_r_val = ~gain_r_val;
0573             gain_r_val += 1;
0574         }
0575         gain_r_val &= 0xffff;
0576     }
0577 
0578     if (lvalue != gain_l_val || rvalue != gain_r_val)
0579         changed = 1;
0580     else
0581         return 0;
0582 
0583     for (i = 0; i < 3; i++) { /* retry 3 times at most */
0584         /* Lch*/
0585         regmap_write(rt711->mbq_regmap, mc->reg, gain_l_val);
0586 
0587         /* Rch */
0588         regmap_write(rt711->mbq_regmap, mc->rreg, gain_r_val);
0589 
0590         regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
0591         regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
0592         if (read_r == gain_r_val && read_l == gain_l_val)
0593             break;
0594     }
0595 
0596     return i == 3 ? -EIO : changed;
0597 }
0598 
0599 static int rt711_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
0600         struct snd_ctl_elem_value *ucontrol)
0601 {
0602     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0603     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0604     struct soc_mixer_control *mc =
0605         (struct soc_mixer_control *)kcontrol->private_value;
0606     unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
0607     unsigned int adc_vol_flag = 0, neg_flag = 0;
0608 
0609     if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
0610         strstr(ucontrol->id.name, "FU0F Capture Volume"))
0611         adc_vol_flag = 1;
0612 
0613     regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
0614     regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
0615 
0616     /* 2's complement value to control value */
0617     if (mc->shift == 8) /* boost gain */
0618         ctl_l = (read_l >> mc->shift) / 10;
0619     else { /* ADC/DAC gain */
0620         ctl_l = read_l;
0621         if (read_l & BIT(15)) {
0622             ctl_l = 0xffff & ~(read_l - 1);
0623             neg_flag = 1;
0624         }
0625         ctl_l *= 100;
0626         ctl_l >>= 8;
0627         if (adc_vol_flag) {
0628             if (neg_flag)
0629                 ctl_l = mc->shift - (ctl_l / 75);
0630             else
0631                 ctl_l = mc->shift + (ctl_l / 75);
0632         } else
0633             ctl_l = mc->max - (ctl_l / 75);
0634     }
0635 
0636     neg_flag = 0;
0637     if (read_l != read_r) {
0638         if (mc->shift == 8) /* boost gain */
0639             ctl_r = (read_r >> mc->shift) / 10;
0640         else { /* ADC/DAC gain */
0641             ctl_r = read_r;
0642             if (read_r & BIT(15)) {
0643                 ctl_r = 0xffff & ~(read_r - 1);
0644                 neg_flag = 1;
0645             }
0646             ctl_r *= 100;
0647             ctl_r >>= 8;
0648             if (adc_vol_flag) {
0649                 if (neg_flag)
0650                     ctl_r = mc->shift - (ctl_r / 75);
0651                 else
0652                     ctl_r = mc->shift + (ctl_r / 75);
0653             } else
0654                 ctl_r = mc->max - (ctl_r / 75);
0655         }
0656     } else
0657         ctl_r = ctl_l;
0658 
0659     ucontrol->value.integer.value[0] = ctl_l;
0660     ucontrol->value.integer.value[1] = ctl_r;
0661 
0662     return 0;
0663 }
0664 
0665 static int rt711_sdca_set_fu0f_capture_ctl(struct rt711_sdca_priv *rt711)
0666 {
0667     int err;
0668     unsigned int ch_l, ch_r;
0669 
0670     ch_l = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_l_mute) ? 0x01 : 0x00;
0671     ch_r = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_r_mute) ? 0x01 : 0x00;
0672 
0673     err = regmap_write(rt711->regmap,
0674             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
0675             RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
0676     if (err < 0)
0677         return err;
0678 
0679     err = regmap_write(rt711->regmap,
0680             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
0681             RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
0682     if (err < 0)
0683         return err;
0684 
0685     return 0;
0686 }
0687 
0688 static int rt711_sdca_set_fu1e_capture_ctl(struct rt711_sdca_priv *rt711)
0689 {
0690     int err;
0691     unsigned int ch_l, ch_r;
0692 
0693     ch_l = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_l_mute) ? 0x01 : 0x00;
0694     ch_r = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_r_mute) ? 0x01 : 0x00;
0695 
0696     err = regmap_write(rt711->regmap,
0697             SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
0698             RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
0699     if (err < 0)
0700         return err;
0701 
0702     err = regmap_write(rt711->regmap,
0703             SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
0704             RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
0705     if (err < 0)
0706         return err;
0707 
0708     return 0;
0709 }
0710 
0711 static int rt711_sdca_fu1e_capture_get(struct snd_kcontrol *kcontrol,
0712             struct snd_ctl_elem_value *ucontrol)
0713 {
0714     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0715     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0716 
0717     ucontrol->value.integer.value[0] = !rt711->fu1e_mixer_l_mute;
0718     ucontrol->value.integer.value[1] = !rt711->fu1e_mixer_r_mute;
0719     return 0;
0720 }
0721 
0722 static int rt711_sdca_fu1e_capture_put(struct snd_kcontrol *kcontrol,
0723             struct snd_ctl_elem_value *ucontrol)
0724 {
0725     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0726     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0727     int err, changed = 0;
0728 
0729     if (rt711->fu1e_mixer_l_mute != !ucontrol->value.integer.value[0] ||
0730         rt711->fu1e_mixer_r_mute != !ucontrol->value.integer.value[1])
0731         changed = 1;
0732 
0733     rt711->fu1e_mixer_l_mute = !ucontrol->value.integer.value[0];
0734     rt711->fu1e_mixer_r_mute = !ucontrol->value.integer.value[1];
0735     err = rt711_sdca_set_fu1e_capture_ctl(rt711);
0736     if (err < 0)
0737         return err;
0738 
0739     return changed;
0740 }
0741 
0742 static int rt711_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
0743             struct snd_ctl_elem_value *ucontrol)
0744 {
0745     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0746     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0747 
0748     ucontrol->value.integer.value[0] = !rt711->fu0f_mixer_l_mute;
0749     ucontrol->value.integer.value[1] = !rt711->fu0f_mixer_r_mute;
0750     return 0;
0751 }
0752 
0753 static int rt711_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
0754             struct snd_ctl_elem_value *ucontrol)
0755 {
0756     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0757     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0758     int err, changed = 0;
0759 
0760     if (rt711->fu0f_mixer_l_mute != !ucontrol->value.integer.value[0] ||
0761         rt711->fu0f_mixer_r_mute != !ucontrol->value.integer.value[1])
0762         changed = 1;
0763 
0764     rt711->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
0765     rt711->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
0766     err = rt711_sdca_set_fu0f_capture_ctl(rt711);
0767     if (err < 0)
0768         return err;
0769 
0770     return changed;
0771 }
0772 
0773 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
0774 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
0775 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
0776 
0777 static const struct snd_kcontrol_new rt711_sdca_snd_controls[] = {
0778     SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
0779         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_L),
0780         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_R),
0781         0x57, 0x57, 0,
0782         rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, out_vol_tlv),
0783     SOC_DOUBLE_EXT("FU1E Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
0784         rt711_sdca_fu1e_capture_get, rt711_sdca_fu1e_capture_put),
0785     SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
0786         rt711_sdca_fu0f_capture_get, rt711_sdca_fu0f_capture_put),
0787     SOC_DOUBLE_R_EXT_TLV("FU1E Capture Volume",
0788         SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_L),
0789         SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_R),
0790         0x17, 0x3f, 0,
0791         rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
0792     SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
0793         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_L),
0794         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_R),
0795         0x17, 0x3f, 0,
0796         rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
0797     SOC_DOUBLE_R_EXT_TLV("FU44 Gain Volume",
0798         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
0799         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
0800         8, 3, 0,
0801         rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
0802     SOC_DOUBLE_R_EXT_TLV("FU15 Gain Volume",
0803         SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
0804         SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
0805         8, 3, 0,
0806         rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
0807 };
0808 
0809 static int rt711_sdca_mux_get(struct snd_kcontrol *kcontrol,
0810             struct snd_ctl_elem_value *ucontrol)
0811 {
0812     struct snd_soc_component *component =
0813         snd_soc_dapm_kcontrol_component(kcontrol);
0814     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0815     unsigned int val = 0, mask_sft;
0816 
0817     if (strstr(ucontrol->id.name, "ADC 22 Mux"))
0818         mask_sft = 10;
0819     else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
0820         mask_sft = 13;
0821     else
0822         return -EINVAL;
0823 
0824     rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
0825         RT711_HDA_LEGACY_MUX_CTL1, &val);
0826 
0827     ucontrol->value.enumerated.item[0] = (val >> mask_sft) & 0x7;
0828 
0829     return 0;
0830 }
0831 
0832 static int rt711_sdca_mux_put(struct snd_kcontrol *kcontrol,
0833             struct snd_ctl_elem_value *ucontrol)
0834 {
0835     struct snd_soc_component *component =
0836         snd_soc_dapm_kcontrol_component(kcontrol);
0837     struct snd_soc_dapm_context *dapm =
0838         snd_soc_dapm_kcontrol_dapm(kcontrol);
0839     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0840     struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
0841     unsigned int *item = ucontrol->value.enumerated.item;
0842     unsigned int val, val2 = 0, change, mask_sft;
0843 
0844     if (item[0] >= e->items)
0845         return -EINVAL;
0846 
0847     if (strstr(ucontrol->id.name, "ADC 22 Mux"))
0848         mask_sft = 10;
0849     else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
0850         mask_sft = 13;
0851     else
0852         return -EINVAL;
0853 
0854     val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
0855 
0856     rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
0857         RT711_HDA_LEGACY_MUX_CTL1, &val2);
0858     val2 = (val2 >> mask_sft) & 0x7;
0859 
0860     if (val == val2)
0861         change = 0;
0862     else
0863         change = 1;
0864 
0865     if (change)
0866         rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
0867             RT711_HDA_LEGACY_MUX_CTL1, 0x7 << mask_sft,
0868             val << mask_sft);
0869 
0870     snd_soc_dapm_mux_update_power(dapm, kcontrol,
0871         item[0], e, NULL);
0872 
0873     return change;
0874 }
0875 
0876 static const char * const adc_mux_text[] = {
0877     "MIC2",
0878     "LINE1",
0879     "LINE2",
0880     "DMIC",
0881 };
0882 
0883 static SOC_ENUM_SINGLE_DECL(
0884     rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
0885 
0886 static SOC_ENUM_SINGLE_DECL(
0887     rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
0888 
0889 static const struct snd_kcontrol_new rt711_sdca_adc22_mux =
0890     SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum,
0891             rt711_sdca_mux_get, rt711_sdca_mux_put);
0892 
0893 static const struct snd_kcontrol_new rt711_sdca_adc23_mux =
0894     SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum,
0895             rt711_sdca_mux_get, rt711_sdca_mux_put);
0896 
0897 static int rt711_sdca_fu05_event(struct snd_soc_dapm_widget *w,
0898     struct snd_kcontrol *kcontrol, int event)
0899 {
0900     struct snd_soc_component *component =
0901         snd_soc_dapm_to_component(w->dapm);
0902     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0903     unsigned char unmute = 0x0, mute = 0x1;
0904 
0905     switch (event) {
0906     case SND_SOC_DAPM_POST_PMU:
0907         regmap_write(rt711->regmap,
0908             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
0909                 RT711_SDCA_CTL_FU_MUTE, CH_L),
0910                 unmute);
0911         regmap_write(rt711->regmap,
0912             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
0913                 RT711_SDCA_CTL_FU_MUTE, CH_R),
0914                 unmute);
0915         break;
0916     case SND_SOC_DAPM_PRE_PMD:
0917         regmap_write(rt711->regmap,
0918             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
0919                 RT711_SDCA_CTL_FU_MUTE, CH_L),
0920                 mute);
0921         regmap_write(rt711->regmap,
0922             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
0923                 RT711_SDCA_CTL_FU_MUTE, CH_R),
0924                 mute);
0925         break;
0926     }
0927     return 0;
0928 }
0929 
0930 static int rt711_sdca_fu0f_event(struct snd_soc_dapm_widget *w,
0931     struct snd_kcontrol *kcontrol, int event)
0932 {
0933     struct snd_soc_component *component =
0934         snd_soc_dapm_to_component(w->dapm);
0935     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0936 
0937     switch (event) {
0938     case SND_SOC_DAPM_POST_PMU:
0939         rt711->fu0f_dapm_mute = false;
0940         rt711_sdca_set_fu0f_capture_ctl(rt711);
0941         break;
0942     case SND_SOC_DAPM_PRE_PMD:
0943         rt711->fu0f_dapm_mute = true;
0944         rt711_sdca_set_fu0f_capture_ctl(rt711);
0945         break;
0946     }
0947     return 0;
0948 }
0949 
0950 static int rt711_sdca_fu1e_event(struct snd_soc_dapm_widget *w,
0951     struct snd_kcontrol *kcontrol, int event)
0952 {
0953     struct snd_soc_component *component =
0954         snd_soc_dapm_to_component(w->dapm);
0955     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0956 
0957     switch (event) {
0958     case SND_SOC_DAPM_POST_PMU:
0959         rt711->fu1e_dapm_mute = false;
0960         rt711_sdca_set_fu1e_capture_ctl(rt711);
0961         break;
0962     case SND_SOC_DAPM_PRE_PMD:
0963         rt711->fu1e_dapm_mute = true;
0964         rt711_sdca_set_fu1e_capture_ctl(rt711);
0965         break;
0966     }
0967     return 0;
0968 }
0969 
0970 static int rt711_sdca_pde28_event(struct snd_soc_dapm_widget *w,
0971     struct snd_kcontrol *kcontrol, int event)
0972 {
0973     struct snd_soc_component *component =
0974         snd_soc_dapm_to_component(w->dapm);
0975     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
0976     unsigned char ps0 = 0x0, ps3 = 0x3;
0977 
0978     switch (event) {
0979     case SND_SOC_DAPM_POST_PMU:
0980         regmap_write(rt711->regmap,
0981             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
0982                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
0983                 ps0);
0984         break;
0985     case SND_SOC_DAPM_PRE_PMD:
0986         regmap_write(rt711->regmap,
0987             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
0988                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
0989                 ps3);
0990         break;
0991     }
0992     return 0;
0993 }
0994 
0995 static int rt711_sdca_pde29_event(struct snd_soc_dapm_widget *w,
0996     struct snd_kcontrol *kcontrol, int event)
0997 {
0998     struct snd_soc_component *component =
0999         snd_soc_dapm_to_component(w->dapm);
1000     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1001     unsigned char ps0 = 0x0, ps3 = 0x3;
1002 
1003     switch (event) {
1004     case SND_SOC_DAPM_POST_PMU:
1005         regmap_write(rt711->regmap,
1006             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1007                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1008                 ps0);
1009         break;
1010     case SND_SOC_DAPM_PRE_PMD:
1011         regmap_write(rt711->regmap,
1012             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1013                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1014                 ps3);
1015         break;
1016     }
1017     return 0;
1018 }
1019 
1020 static int rt711_sdca_pde2a_event(struct snd_soc_dapm_widget *w,
1021     struct snd_kcontrol *kcontrol, int event)
1022 {
1023     struct snd_soc_component *component =
1024         snd_soc_dapm_to_component(w->dapm);
1025     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1026     unsigned char ps0 = 0x0, ps3 = 0x3;
1027 
1028     switch (event) {
1029     case SND_SOC_DAPM_POST_PMU:
1030         regmap_write(rt711->regmap,
1031             SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1032                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1033                 ps0);
1034         break;
1035     case SND_SOC_DAPM_PRE_PMD:
1036         regmap_write(rt711->regmap,
1037             SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1038                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1039                 ps3);
1040         break;
1041     }
1042     return 0;
1043 }
1044 
1045 static int rt711_sdca_line1_power_event(struct snd_soc_dapm_widget *w,
1046             struct snd_kcontrol *kcontrol, int event)
1047 {
1048     struct snd_soc_component *component =
1049         snd_soc_dapm_to_component(w->dapm);
1050     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1051     static unsigned int sel_mode = 0xffff;
1052 
1053     switch (event) {
1054     case SND_SOC_DAPM_POST_PMU:
1055         regmap_read(rt711->regmap,
1056             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1057                 RT711_SDCA_CTL_SELECTED_MODE, 0),
1058                 &sel_mode);
1059         regmap_write(rt711->regmap,
1060             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1061                 RT711_SDCA_CTL_VENDOR_DEF, 0),
1062                 0x1);
1063         regmap_write(rt711->regmap,
1064             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1065                 RT711_SDCA_CTL_SELECTED_MODE, 0),
1066                 0x7);
1067         break;
1068     case SND_SOC_DAPM_PRE_PMD:
1069         regmap_write(rt711->regmap,
1070             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1071                 RT711_SDCA_CTL_VENDOR_DEF, 0),
1072                 0x0);
1073         if (sel_mode != 0xffff)
1074             regmap_write(rt711->regmap,
1075                 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1076                 RT711_SDCA_CTL_SELECTED_MODE, 0),
1077                 sel_mode);
1078         break;
1079     }
1080 
1081     return 0;
1082 }
1083 
1084 static int rt711_sdca_line2_power_event(struct snd_soc_dapm_widget *w,
1085             struct snd_kcontrol *kcontrol, int event)
1086 {
1087     struct snd_soc_component *component =
1088         snd_soc_dapm_to_component(w->dapm);
1089     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1090     unsigned char ps0 = 0x0, ps3 = 0x3;
1091 
1092     switch (event) {
1093     case SND_SOC_DAPM_POST_PMU:
1094         regmap_write(rt711->regmap,
1095             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1096                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1097                 ps0);
1098         regmap_write(rt711->regmap,
1099             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1100                 RT711_SDCA_CTL_VENDOR_DEF, 0),
1101                 0x1);
1102         break;
1103     case SND_SOC_DAPM_PRE_PMD:
1104         regmap_write(rt711->regmap,
1105             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1106                 RT711_SDCA_CTL_VENDOR_DEF, 0),
1107                 0x0);
1108         regmap_write(rt711->regmap,
1109             SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1110                 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1111                 ps3);
1112         break;
1113     }
1114 
1115     return 0;
1116 }
1117 
1118 static const struct snd_soc_dapm_widget rt711_sdca_dapm_widgets[] = {
1119     SND_SOC_DAPM_OUTPUT("HP"),
1120     SND_SOC_DAPM_INPUT("MIC2"),
1121     SND_SOC_DAPM_INPUT("DMIC1"),
1122     SND_SOC_DAPM_INPUT("DMIC2"),
1123     SND_SOC_DAPM_INPUT("LINE1"),
1124     SND_SOC_DAPM_INPUT("LINE2"),
1125 
1126     SND_SOC_DAPM_PGA_E("LINE1 Power", SND_SOC_NOPM,
1127         0, 0, NULL, 0, rt711_sdca_line1_power_event,
1128         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1129     SND_SOC_DAPM_PGA_E("LINE2 Power", SND_SOC_NOPM,
1130         0, 0, NULL, 0, rt711_sdca_line2_power_event,
1131         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1132 
1133     SND_SOC_DAPM_SUPPLY("PDE 28", SND_SOC_NOPM, 0, 0,
1134         rt711_sdca_pde28_event,
1135         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1136     SND_SOC_DAPM_SUPPLY("PDE 29", SND_SOC_NOPM, 0, 0,
1137         rt711_sdca_pde29_event,
1138         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1139     SND_SOC_DAPM_SUPPLY("PDE 2A", SND_SOC_NOPM, 0, 0,
1140         rt711_sdca_pde2a_event,
1141         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1142 
1143     SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0,
1144         rt711_sdca_fu05_event,
1145         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1146     SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0,
1147         rt711_sdca_fu0f_event,
1148         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1149     SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0,
1150         rt711_sdca_fu1e_event,
1151         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1152     SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
1153         &rt711_sdca_adc22_mux),
1154     SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
1155         &rt711_sdca_adc23_mux),
1156 
1157     SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
1158     SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
1159     SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
1160 };
1161 
1162 static const struct snd_soc_dapm_route rt711_sdca_audio_map[] = {
1163     {"FU 05", NULL, "DP3RX"},
1164     {"DP2TX", NULL, "FU 0F"},
1165     {"DP4TX", NULL, "FU 1E"},
1166 
1167     {"LINE1 Power", NULL, "LINE1"},
1168     {"LINE2 Power", NULL, "LINE2"},
1169     {"HP", NULL, "PDE 28"},
1170     {"FU 0F", NULL, "PDE 29"},
1171     {"FU 1E", NULL, "PDE 2A"},
1172 
1173     {"FU 0F", NULL, "ADC 22 Mux"},
1174     {"FU 1E", NULL, "ADC 23 Mux"},
1175     {"ADC 22 Mux", "DMIC", "DMIC1"},
1176     {"ADC 22 Mux", "LINE1", "LINE1 Power"},
1177     {"ADC 22 Mux", "LINE2", "LINE2 Power"},
1178     {"ADC 22 Mux", "MIC2", "MIC2"},
1179     {"ADC 23 Mux", "DMIC", "DMIC2"},
1180     {"ADC 23 Mux", "LINE1", "LINE1 Power"},
1181     {"ADC 23 Mux", "LINE2", "LINE2 Power"},
1182     {"ADC 23 Mux", "MIC2", "MIC2"},
1183 
1184     {"HP", NULL, "FU 05"},
1185 };
1186 
1187 static int rt711_sdca_parse_dt(struct rt711_sdca_priv *rt711, struct device *dev)
1188 {
1189     device_property_read_u32(dev, "realtek,jd-src", &rt711->jd_src);
1190 
1191     return 0;
1192 }
1193 
1194 static int rt711_sdca_probe(struct snd_soc_component *component)
1195 {
1196     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1197     int ret;
1198 
1199     rt711_sdca_parse_dt(rt711, &rt711->slave->dev);
1200     rt711->component = component;
1201 
1202     ret = pm_runtime_resume(component->dev);
1203     if (ret < 0 && ret != -EACCES)
1204         return ret;
1205 
1206     return 0;
1207 }
1208 
1209 static const struct snd_soc_component_driver soc_sdca_dev_rt711 = {
1210     .probe = rt711_sdca_probe,
1211     .controls = rt711_sdca_snd_controls,
1212     .num_controls = ARRAY_SIZE(rt711_sdca_snd_controls),
1213     .dapm_widgets = rt711_sdca_dapm_widgets,
1214     .num_dapm_widgets = ARRAY_SIZE(rt711_sdca_dapm_widgets),
1215     .dapm_routes = rt711_sdca_audio_map,
1216     .num_dapm_routes = ARRAY_SIZE(rt711_sdca_audio_map),
1217     .set_jack = rt711_sdca_set_jack_detect,
1218     .endianness = 1,
1219 };
1220 
1221 static int rt711_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
1222                 int direction)
1223 {
1224     struct sdw_stream_data *stream;
1225 
1226     if (!sdw_stream)
1227         return 0;
1228 
1229     stream = kzalloc(sizeof(*stream), GFP_KERNEL);
1230     if (!stream)
1231         return -ENOMEM;
1232 
1233     stream->sdw_stream = sdw_stream;
1234 
1235     /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
1236     if (direction == SNDRV_PCM_STREAM_PLAYBACK)
1237         dai->playback_dma_data = stream;
1238     else
1239         dai->capture_dma_data = stream;
1240 
1241     return 0;
1242 }
1243 
1244 static void rt711_sdca_shutdown(struct snd_pcm_substream *substream,
1245                 struct snd_soc_dai *dai)
1246 {
1247     struct sdw_stream_data *stream;
1248 
1249     stream = snd_soc_dai_get_dma_data(dai, substream);
1250     snd_soc_dai_set_dma_data(dai, substream, NULL);
1251     kfree(stream);
1252 }
1253 
1254 static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1255                 struct snd_pcm_hw_params *params,
1256                 struct snd_soc_dai *dai)
1257 {
1258     struct snd_soc_component *component = dai->component;
1259     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1260     struct sdw_stream_config stream_config;
1261     struct sdw_port_config port_config;
1262     enum sdw_data_direction direction;
1263     struct sdw_stream_data *stream;
1264     int retval, port, num_channels;
1265     unsigned int sampling_rate;
1266 
1267     dev_dbg(dai->dev, "%s %s", __func__, dai->name);
1268     stream = snd_soc_dai_get_dma_data(dai, substream);
1269 
1270     if (!stream)
1271         return -EINVAL;
1272 
1273     if (!rt711->slave)
1274         return -EINVAL;
1275 
1276     /* SoundWire specific configuration */
1277     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1278         direction = SDW_DATA_DIR_RX;
1279         port = 3;
1280     } else {
1281         direction = SDW_DATA_DIR_TX;
1282         if (dai->id == RT711_AIF1)
1283             port = 2;
1284         else if (dai->id == RT711_AIF2)
1285             port = 4;
1286         else
1287             return -EINVAL;
1288     }
1289 
1290     stream_config.frame_rate = params_rate(params);
1291     stream_config.ch_count = params_channels(params);
1292     stream_config.bps = snd_pcm_format_width(params_format(params));
1293     stream_config.direction = direction;
1294 
1295     num_channels = params_channels(params);
1296     port_config.ch_mask = GENMASK(num_channels - 1, 0);
1297     port_config.num = port;
1298 
1299     retval = sdw_stream_add_slave(rt711->slave, &stream_config,
1300                     &port_config, 1, stream->sdw_stream);
1301     if (retval) {
1302         dev_err(dai->dev, "Unable to configure port\n");
1303         return retval;
1304     }
1305 
1306     if (params_channels(params) > 16) {
1307         dev_err(component->dev, "Unsupported channels %d\n",
1308             params_channels(params));
1309         return -EINVAL;
1310     }
1311 
1312     /* sampling rate configuration */
1313     switch (params_rate(params)) {
1314     case 44100:
1315         sampling_rate = RT711_SDCA_RATE_44100HZ;
1316         break;
1317     case 48000:
1318         sampling_rate = RT711_SDCA_RATE_48000HZ;
1319         break;
1320     case 96000:
1321         sampling_rate = RT711_SDCA_RATE_96000HZ;
1322         break;
1323     case 192000:
1324         sampling_rate = RT711_SDCA_RATE_192000HZ;
1325         break;
1326     default:
1327         dev_err(component->dev, "Rate %d is not supported\n",
1328             params_rate(params));
1329         return -EINVAL;
1330     }
1331 
1332     /* set sampling frequency */
1333     regmap_write(rt711->regmap,
1334         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS01, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1335         sampling_rate);
1336     regmap_write(rt711->regmap,
1337         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS11, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1338         sampling_rate);
1339     regmap_write(rt711->regmap,
1340         SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_CS1F, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1341         sampling_rate);
1342 
1343     return 0;
1344 }
1345 
1346 static int rt711_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1347                 struct snd_soc_dai *dai)
1348 {
1349     struct snd_soc_component *component = dai->component;
1350     struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1351     struct sdw_stream_data *stream =
1352         snd_soc_dai_get_dma_data(dai, substream);
1353 
1354     if (!rt711->slave)
1355         return -EINVAL;
1356 
1357     sdw_stream_remove_slave(rt711->slave, stream->sdw_stream);
1358     return 0;
1359 }
1360 
1361 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1362             SNDRV_PCM_RATE_192000)
1363 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1364             SNDRV_PCM_FMTBIT_S24_LE)
1365 
1366 static const struct snd_soc_dai_ops rt711_sdca_ops = {
1367     .hw_params  = rt711_sdca_pcm_hw_params,
1368     .hw_free    = rt711_sdca_pcm_hw_free,
1369     .set_stream = rt711_sdca_set_sdw_stream,
1370     .shutdown   = rt711_sdca_shutdown,
1371 };
1372 
1373 static struct snd_soc_dai_driver rt711_sdca_dai[] = {
1374     {
1375         .name = "rt711-sdca-aif1",
1376         .id = RT711_AIF1,
1377         .playback = {
1378             .stream_name = "DP3 Playback",
1379             .channels_min = 1,
1380             .channels_max = 2,
1381             .rates = RT711_STEREO_RATES,
1382             .formats = RT711_FORMATS,
1383         },
1384         .capture = {
1385             .stream_name = "DP2 Capture",
1386             .channels_min = 1,
1387             .channels_max = 2,
1388             .rates = RT711_STEREO_RATES,
1389             .formats = RT711_FORMATS,
1390         },
1391         .ops = &rt711_sdca_ops,
1392     },
1393     {
1394         .name = "rt711-sdca-aif2",
1395         .id = RT711_AIF2,
1396         .capture = {
1397             .stream_name = "DP4 Capture",
1398             .channels_min = 1,
1399             .channels_max = 2,
1400             .rates = RT711_STEREO_RATES,
1401             .formats = RT711_FORMATS,
1402         },
1403         .ops = &rt711_sdca_ops,
1404     }
1405 };
1406 
1407 int rt711_sdca_init(struct device *dev, struct regmap *regmap,
1408             struct regmap *mbq_regmap, struct sdw_slave *slave)
1409 {
1410     struct rt711_sdca_priv *rt711;
1411     int ret;
1412 
1413     rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL);
1414     if (!rt711)
1415         return -ENOMEM;
1416 
1417     dev_set_drvdata(dev, rt711);
1418     rt711->slave = slave;
1419     rt711->regmap = regmap;
1420     rt711->mbq_regmap = mbq_regmap;
1421 
1422     mutex_init(&rt711->calibrate_mutex);
1423     mutex_init(&rt711->disable_irq_lock);
1424 
1425     INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_sdca_jack_detect_handler);
1426     INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_sdca_btn_check_handler);
1427 
1428     /*
1429      * Mark hw_init to false
1430      * HW init will be performed when device reports present
1431      */
1432     rt711->hw_init = false;
1433     rt711->first_hw_init = false;
1434     rt711->fu0f_dapm_mute = true;
1435     rt711->fu1e_dapm_mute = true;
1436     rt711->fu0f_mixer_l_mute = rt711->fu0f_mixer_r_mute = true;
1437     rt711->fu1e_mixer_l_mute = rt711->fu1e_mixer_r_mute = true;
1438 
1439     /* JD source uses JD2 in default */
1440     rt711->jd_src = RT711_JD2;
1441 
1442     ret =  devm_snd_soc_register_component(dev,
1443             &soc_sdca_dev_rt711,
1444             rt711_sdca_dai,
1445             ARRAY_SIZE(rt711_sdca_dai));
1446 
1447     dev_dbg(&slave->dev, "%s\n", __func__);
1448 
1449     return ret;
1450 }
1451 
1452 static void rt711_sdca_vd0_io_init(struct rt711_sdca_priv *rt711)
1453 {
1454     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1455         RT711_GPIO_TEST_MODE_CTL2, 0x0e00);
1456     rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1457         RT711_HDA_LEGACY_GPIO_CTL, 0x0008);
1458 
1459     regmap_write(rt711->regmap, 0x2f5a, 0x01);
1460 
1461     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1462         RT711_ADC27_VOL_SET, 0x8728);
1463 
1464     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1465         RT711_COMBO_JACK_AUTO_CTL3, 0xa472);
1466 
1467     regmap_write(rt711->regmap, 0x2f50, 0x02);
1468 
1469     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
1470         RT711_MISC_POWER_CTL4, 0x6000, 0x6000);
1471 
1472     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1473         RT711_COMBO_JACK_AUTO_CTL3, 0x000c, 0x000c);
1474 
1475     rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1476         RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1477 
1478     rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1479         RT711_VAD_SRAM_CTL1, 0x0050);
1480 }
1481 
1482 static void rt711_sdca_vd1_io_init(struct rt711_sdca_priv *rt711)
1483 {
1484     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1485         RT711_HDA_LEGACY_UNSOLICITED_CTL, 0x0300, 0x0000);
1486 
1487     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1488         RT711_COMBO_JACK_AUTO_CTL3, 0xa43e);
1489 
1490     regmap_write(rt711->regmap, 0x2f5a, 0x05);
1491 
1492     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1493         RT711_JD_CTRL6, 0x0500);
1494 
1495     rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1496         RT711_DMIC_CTL1, 0x6173);
1497 
1498     rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1499         RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1500 
1501     rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1502         RT711_VAD_SRAM_CTL1, 0x0050);
1503 }
1504 
1505 int rt711_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1506 {
1507     struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
1508     int ret = 0;
1509     unsigned int val;
1510 
1511     rt711->disable_irq = false;
1512 
1513     if (rt711->hw_init)
1514         return 0;
1515 
1516     if (rt711->first_hw_init) {
1517         regcache_cache_only(rt711->regmap, false);
1518         regcache_cache_bypass(rt711->regmap, true);
1519         regcache_cache_only(rt711->mbq_regmap, false);
1520         regcache_cache_bypass(rt711->mbq_regmap, true);
1521     } else {
1522         /*
1523          * PM runtime is only enabled when a Slave reports as Attached
1524          */
1525 
1526         /* set autosuspend parameters */
1527         pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
1528         pm_runtime_use_autosuspend(&slave->dev);
1529 
1530         /* update count of parent 'active' children */
1531         pm_runtime_set_active(&slave->dev);
1532 
1533         /* make sure the device does not suspend immediately */
1534         pm_runtime_mark_last_busy(&slave->dev);
1535 
1536         pm_runtime_enable(&slave->dev);
1537     }
1538 
1539     pm_runtime_get_noresume(&slave->dev);
1540 
1541     rt711_sdca_reset(rt711);
1542 
1543     rt711_sdca_index_read(rt711, RT711_VENDOR_REG, RT711_JD_PRODUCT_NUM, &val);
1544     rt711->hw_ver = val & 0xf;
1545 
1546     if (rt711->hw_ver == RT711_VER_VD0)
1547         rt711_sdca_vd0_io_init(rt711);
1548     else
1549         rt711_sdca_vd1_io_init(rt711);
1550 
1551     /* DP4 mux select from 08_filter_Out_pri */
1552     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1553         RT711_FILTER_SRC_SEL, 0x1800, 0x0800);
1554 
1555     /* ge_exclusive_inbox_en disable */
1556     rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1557         RT711_PUSH_BTN_INT_CTL0, 0x20, 0x00);
1558 
1559     /* calibration */
1560     ret = rt711_sdca_calibration(rt711);
1561     if (ret < 0)
1562         dev_err(dev, "%s, calibration failed!\n", __func__);
1563 
1564     /* HP output enable */
1565     regmap_write(rt711->regmap,
1566         SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_OT1, RT711_SDCA_CTL_VENDOR_DEF, 0), 0x4);
1567 
1568     /*
1569      * if set_jack callback occurred early than io_init,
1570      * we set up the jack detection function now
1571      */
1572     if (rt711->hs_jack)
1573         rt711_sdca_jack_init(rt711);
1574 
1575     if (rt711->first_hw_init) {
1576         regcache_cache_bypass(rt711->regmap, false);
1577         regcache_mark_dirty(rt711->regmap);
1578         regcache_cache_bypass(rt711->mbq_regmap, false);
1579         regcache_mark_dirty(rt711->mbq_regmap);
1580     } else
1581         rt711->first_hw_init = true;
1582 
1583     /* Mark Slave initialization complete */
1584     rt711->hw_init = true;
1585 
1586     pm_runtime_mark_last_busy(&slave->dev);
1587     pm_runtime_put_autosuspend(&slave->dev);
1588 
1589     dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1590     return 0;
1591 }
1592 
1593 MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver");
1594 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1595 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!