Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // rt700.c -- rt700 ALSA SoC audio driver
0004 //
0005 // Copyright(c) 2019 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/pm.h>
0016 #include <linux/soundwire/sdw.h>
0017 #include <linux/regmap.h>
0018 #include <linux/slab.h>
0019 #include <sound/core.h>
0020 #include <sound/pcm.h>
0021 #include <sound/pcm_params.h>
0022 #include <sound/soc.h>
0023 #include <sound/soc-dapm.h>
0024 #include <sound/initval.h>
0025 #include <sound/tlv.h>
0026 #include <sound/hda_verbs.h>
0027 #include <sound/jack.h>
0028 
0029 #include "rt700.h"
0030 
0031 static int rt700_index_write(struct regmap *regmap,
0032         unsigned int reg, unsigned int value)
0033 {
0034     int ret;
0035     unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
0036 
0037     ret = regmap_write(regmap, addr, value);
0038     if (ret < 0)
0039         pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
0040             addr, value, ret);
0041 
0042     return ret;
0043 }
0044 
0045 static int rt700_index_read(struct regmap *regmap,
0046         unsigned int reg, unsigned int *value)
0047 {
0048     int ret;
0049     unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
0050 
0051     *value = 0;
0052     ret = regmap_read(regmap, addr, value);
0053     if (ret < 0)
0054         pr_err("Failed to get private value: %06x => %04x ret=%d\n",
0055             addr, *value, ret);
0056 
0057     return ret;
0058 }
0059 
0060 static unsigned int rt700_button_detect(struct rt700_priv *rt700)
0061 {
0062     unsigned int btn_type = 0, val80, val81;
0063     int ret;
0064 
0065     ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE1, &val80);
0066     if (ret < 0)
0067         goto read_error;
0068     ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE2, &val81);
0069     if (ret < 0)
0070         goto read_error;
0071 
0072     val80 &= 0x0381;
0073     val81 &= 0xff00;
0074 
0075     switch (val80) {
0076     case 0x0200:
0077     case 0x0100:
0078     case 0x0080:
0079         btn_type |= SND_JACK_BTN_0;
0080         break;
0081     case 0x0001:
0082         btn_type |= SND_JACK_BTN_3;
0083         break;
0084     }
0085     switch (val81) {
0086     case 0x8000:
0087     case 0x4000:
0088     case 0x2000:
0089         btn_type |= SND_JACK_BTN_1;
0090         break;
0091     case 0x1000:
0092     case 0x0800:
0093     case 0x0400:
0094         btn_type |= SND_JACK_BTN_2;
0095         break;
0096     case 0x0200:
0097     case 0x0100:
0098         btn_type |= SND_JACK_BTN_3;
0099         break;
0100     }
0101 read_error:
0102     return btn_type;
0103 }
0104 
0105 static int rt700_headset_detect(struct rt700_priv *rt700)
0106 {
0107     unsigned int buf, loop = 0;
0108     int ret;
0109     unsigned int jack_status = 0, reg;
0110 
0111     ret = rt700_index_read(rt700->regmap,
0112                     RT700_COMBO_JACK_AUTO_CTL2, &buf);
0113     if (ret < 0)
0114         goto io_error;
0115 
0116     while (loop < 500 &&
0117         (buf & RT700_COMBOJACK_AUTO_DET_STATUS) == 0) {
0118         loop++;
0119 
0120         usleep_range(9000, 10000);
0121         ret = rt700_index_read(rt700->regmap,
0122                     RT700_COMBO_JACK_AUTO_CTL2, &buf);
0123         if (ret < 0)
0124             goto io_error;
0125 
0126         reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
0127         ret = regmap_read(rt700->regmap, reg, &jack_status);
0128         if ((jack_status & (1 << 31)) == 0)
0129             goto remove_error;
0130     }
0131 
0132     if (loop >= 500)
0133         goto to_error;
0134 
0135     if (buf & RT700_COMBOJACK_AUTO_DET_TRS)
0136         rt700->jack_type = SND_JACK_HEADPHONE;
0137     else if ((buf & RT700_COMBOJACK_AUTO_DET_CTIA) ||
0138         (buf & RT700_COMBOJACK_AUTO_DET_OMTP))
0139         rt700->jack_type = SND_JACK_HEADSET;
0140 
0141     return 0;
0142 
0143 to_error:
0144     ret = -ETIMEDOUT;
0145     pr_err_ratelimited("Time-out error in %s\n", __func__);
0146     return ret;
0147 io_error:
0148     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0149     return ret;
0150 remove_error:
0151     pr_err_ratelimited("Jack removal in %s\n", __func__);
0152     return -ENODEV;
0153 }
0154 
0155 static void rt700_jack_detect_handler(struct work_struct *work)
0156 {
0157     struct rt700_priv *rt700 =
0158         container_of(work, struct rt700_priv, jack_detect_work.work);
0159     int btn_type = 0, ret;
0160     unsigned int jack_status = 0, reg;
0161 
0162     if (!rt700->hs_jack)
0163         return;
0164 
0165     if (!rt700->component->card || !rt700->component->card->instantiated)
0166         return;
0167 
0168     reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
0169     ret = regmap_read(rt700->regmap, reg, &jack_status);
0170     if (ret < 0)
0171         goto io_error;
0172 
0173     /* pin attached */
0174     if (jack_status & (1 << 31)) {
0175         /* jack in */
0176         if (rt700->jack_type == 0) {
0177             ret = rt700_headset_detect(rt700);
0178             if (ret < 0)
0179                 return;
0180             if (rt700->jack_type == SND_JACK_HEADSET)
0181                 btn_type = rt700_button_detect(rt700);
0182         } else if (rt700->jack_type == SND_JACK_HEADSET) {
0183             /* jack is already in, report button event */
0184             btn_type = rt700_button_detect(rt700);
0185         }
0186     } else {
0187         /* jack out */
0188         rt700->jack_type = 0;
0189     }
0190 
0191     dev_dbg(&rt700->slave->dev,
0192         "in %s, jack_type=0x%x\n", __func__, rt700->jack_type);
0193     dev_dbg(&rt700->slave->dev,
0194         "in %s, btn_type=0x%x\n", __func__, btn_type);
0195 
0196     snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
0197             SND_JACK_HEADSET |
0198             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0199             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0200 
0201     if (btn_type) {
0202         /* button released */
0203         snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
0204             SND_JACK_HEADSET |
0205             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0206             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0207 
0208         mod_delayed_work(system_power_efficient_wq,
0209             &rt700->jack_btn_check_work, msecs_to_jiffies(200));
0210     }
0211 
0212     return;
0213 
0214 io_error:
0215     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0216 }
0217 
0218 static void rt700_btn_check_handler(struct work_struct *work)
0219 {
0220     struct rt700_priv *rt700 = container_of(work, struct rt700_priv,
0221         jack_btn_check_work.work);
0222     int btn_type = 0, ret;
0223     unsigned int jack_status = 0, reg;
0224 
0225     reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
0226     ret = regmap_read(rt700->regmap, reg, &jack_status);
0227     if (ret < 0)
0228         goto io_error;
0229 
0230     /* pin attached */
0231     if (jack_status & (1 << 31)) {
0232         if (rt700->jack_type == SND_JACK_HEADSET) {
0233             /* jack is already in, report button event */
0234             btn_type = rt700_button_detect(rt700);
0235         }
0236     } else {
0237         rt700->jack_type = 0;
0238     }
0239 
0240     /* cbj comparator */
0241     ret = rt700_index_read(rt700->regmap, RT700_COMBO_JACK_AUTO_CTL2, &reg);
0242     if (ret < 0)
0243         goto io_error;
0244 
0245     if ((reg & 0xf0) == 0xf0)
0246         btn_type = 0;
0247 
0248     dev_dbg(&rt700->slave->dev,
0249         "%s, btn_type=0x%x\n",  __func__, btn_type);
0250     snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
0251             SND_JACK_HEADSET |
0252             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0253             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0254 
0255     if (btn_type) {
0256         /* button released */
0257         snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
0258             SND_JACK_HEADSET |
0259             SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0260             SND_JACK_BTN_2 | SND_JACK_BTN_3);
0261 
0262         mod_delayed_work(system_power_efficient_wq,
0263             &rt700->jack_btn_check_work, msecs_to_jiffies(200));
0264     }
0265 
0266     return;
0267 
0268 io_error:
0269     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0270 }
0271 
0272 static void rt700_jack_init(struct rt700_priv *rt700)
0273 {
0274     struct snd_soc_dapm_context *dapm =
0275         snd_soc_component_get_dapm(rt700->component);
0276 
0277     /* power on */
0278     if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
0279         regmap_write(rt700->regmap,
0280             RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
0281 
0282     if (rt700->hs_jack) {
0283         /* Enable Jack Detection */
0284         regmap_write(rt700->regmap,
0285             RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x82);
0286         regmap_write(rt700->regmap,
0287             RT700_SET_HP_UNSOLICITED_ENABLE, 0x81);
0288         regmap_write(rt700->regmap,
0289             RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x83);
0290         rt700_index_write(rt700->regmap, 0x10, 0x2420);
0291         rt700_index_write(rt700->regmap, 0x19, 0x2e11);
0292 
0293         dev_dbg(&rt700->slave->dev, "in %s enable\n", __func__);
0294 
0295         mod_delayed_work(system_power_efficient_wq,
0296             &rt700->jack_detect_work, msecs_to_jiffies(250));
0297     } else {
0298         regmap_write(rt700->regmap,
0299             RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x00);
0300         regmap_write(rt700->regmap,
0301             RT700_SET_HP_UNSOLICITED_ENABLE, 0x00);
0302         regmap_write(rt700->regmap,
0303             RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x00);
0304 
0305         dev_dbg(&rt700->slave->dev, "in %s disable\n", __func__);
0306     }
0307 
0308     /* power off */
0309     if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
0310         regmap_write(rt700->regmap,
0311             RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
0312 }
0313 
0314 static int rt700_set_jack_detect(struct snd_soc_component *component,
0315     struct snd_soc_jack *hs_jack, void *data)
0316 {
0317     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0318     int ret;
0319 
0320     rt700->hs_jack = hs_jack;
0321 
0322     ret = pm_runtime_resume_and_get(component->dev);
0323     if (ret < 0) {
0324         if (ret != -EACCES) {
0325             dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
0326             return ret;
0327         }
0328 
0329         /* pm_runtime not enabled yet */
0330         dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
0331         return 0;
0332     }
0333 
0334     rt700_jack_init(rt700);
0335 
0336     pm_runtime_mark_last_busy(component->dev);
0337     pm_runtime_put_autosuspend(component->dev);
0338 
0339     return 0;
0340 }
0341 
0342 static void rt700_get_gain(struct rt700_priv *rt700, unsigned int addr_h,
0343                 unsigned int addr_l, unsigned int val_h,
0344                 unsigned int *r_val, unsigned int *l_val)
0345 {
0346     /* R Channel */
0347     *r_val = (val_h << 8);
0348     regmap_read(rt700->regmap, addr_l, r_val);
0349 
0350     /* L Channel */
0351     val_h |= 0x20;
0352     *l_val = (val_h << 8);
0353     regmap_read(rt700->regmap, addr_h, l_val);
0354 }
0355 
0356 /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
0357 static int rt700_set_amp_gain_put(struct snd_kcontrol *kcontrol,
0358         struct snd_ctl_elem_value *ucontrol)
0359 {
0360     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0361     struct snd_soc_dapm_context *dapm =
0362         snd_soc_component_get_dapm(component);
0363     struct soc_mixer_control *mc =
0364         (struct soc_mixer_control *)kcontrol->private_value;
0365     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0366     unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
0367     unsigned int read_ll, read_rl;
0368     int i;
0369 
0370     /* Can't use update bit function, so read the original value first */
0371     addr_h = mc->reg;
0372     addr_l = mc->rreg;
0373     if (mc->shift == RT700_DIR_OUT_SFT) /* output */
0374         val_h = 0x80;
0375     else /* input */
0376         val_h = 0x0;
0377 
0378     rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
0379 
0380     /* L Channel */
0381     if (mc->invert) {
0382         /* for mute */
0383         val_ll = (mc->max - ucontrol->value.integer.value[0]) << 7;
0384         /* keep gain */
0385         read_ll = read_ll & 0x7f;
0386         val_ll |= read_ll;
0387     } else {
0388         /* for gain */
0389         val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
0390         if (val_ll > mc->max)
0391             val_ll = mc->max;
0392         /* keep mute status */
0393         read_ll = read_ll & 0x80;
0394         val_ll |= read_ll;
0395     }
0396 
0397     if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
0398         regmap_write(rt700->regmap,
0399                 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
0400 
0401     /* R Channel */
0402     if (mc->invert) {
0403         /* for mute */
0404         val_lr = (mc->max - ucontrol->value.integer.value[1]) << 7;
0405         /* keep gain */
0406         read_rl = read_rl & 0x7f;
0407         val_lr |= read_rl;
0408     } else {
0409         /* for gain */
0410         val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
0411         if (val_lr > mc->max)
0412             val_lr = mc->max;
0413         /* keep mute status */
0414         read_rl = read_rl & 0x80;
0415         val_lr |= read_rl;
0416     }
0417 
0418     for (i = 0; i < 3; i++) { /* retry 3 times at most */
0419         if (val_ll == val_lr) {
0420             /* Set both L/R channels at the same time */
0421             val_h = (1 << mc->shift) | (3 << 4);
0422             regmap_write(rt700->regmap,
0423                 addr_h, (val_h << 8 | val_ll));
0424             regmap_write(rt700->regmap,
0425                 addr_l, (val_h << 8 | val_ll));
0426         } else {
0427             /* Lch*/
0428             val_h = (1 << mc->shift) | (1 << 5);
0429             regmap_write(rt700->regmap,
0430                 addr_h, (val_h << 8 | val_ll));
0431 
0432             /* Rch */
0433             val_h = (1 << mc->shift) | (1 << 4);
0434             regmap_write(rt700->regmap,
0435                 addr_l, (val_h << 8 | val_lr));
0436         }
0437         /* check result */
0438         if (mc->shift == RT700_DIR_OUT_SFT) /* output */
0439             val_h = 0x80;
0440         else /* input */
0441             val_h = 0x0;
0442 
0443         rt700_get_gain(rt700, addr_h, addr_l, val_h,
0444                     &read_rl, &read_ll);
0445         if (read_rl == val_lr && read_ll == val_ll)
0446             break;
0447     }
0448 
0449     if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
0450         regmap_write(rt700->regmap,
0451                 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
0452     return 0;
0453 }
0454 
0455 static int rt700_set_amp_gain_get(struct snd_kcontrol *kcontrol,
0456         struct snd_ctl_elem_value *ucontrol)
0457 {
0458     struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
0459     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0460     struct soc_mixer_control *mc =
0461         (struct soc_mixer_control *)kcontrol->private_value;
0462     unsigned int addr_h, addr_l, val_h;
0463     unsigned int read_ll, read_rl;
0464 
0465     addr_h = mc->reg;
0466     addr_l = mc->rreg;
0467     if (mc->shift == RT700_DIR_OUT_SFT) /* output */
0468         val_h = 0x80;
0469     else /* input */
0470         val_h = 0x0;
0471 
0472     rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
0473 
0474     if (mc->invert) {
0475         /* for mute status */
0476         read_ll = !((read_ll & 0x80) >> RT700_MUTE_SFT);
0477         read_rl = !((read_rl & 0x80) >> RT700_MUTE_SFT);
0478     } else {
0479         /* for gain */
0480         read_ll = read_ll & 0x7f;
0481         read_rl = read_rl & 0x7f;
0482     }
0483     ucontrol->value.integer.value[0] = read_ll;
0484     ucontrol->value.integer.value[1] = read_rl;
0485 
0486     return 0;
0487 }
0488 
0489 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
0490 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
0491 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
0492 
0493 static const struct snd_kcontrol_new rt700_snd_controls[] = {
0494     SOC_DOUBLE_R_EXT_TLV("DAC Front Playback Volume",
0495         RT700_SET_GAIN_DAC1_H, RT700_SET_GAIN_DAC1_L,
0496         RT700_DIR_OUT_SFT, 0x57, 0,
0497         rt700_set_amp_gain_get, rt700_set_amp_gain_put, out_vol_tlv),
0498     SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
0499         RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
0500         RT700_DIR_IN_SFT, 1, 1,
0501         rt700_set_amp_gain_get, rt700_set_amp_gain_put),
0502     SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
0503         RT700_SET_GAIN_ADC1_H,  RT700_SET_GAIN_ADC1_L,
0504         RT700_DIR_IN_SFT, 1, 1,
0505         rt700_set_amp_gain_get, rt700_set_amp_gain_put),
0506     SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
0507         RT700_SET_GAIN_ADC2_H,  RT700_SET_GAIN_ADC2_L,
0508         RT700_DIR_IN_SFT, 0x3f, 0,
0509         rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
0510     SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
0511         RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
0512         RT700_DIR_IN_SFT, 0x3f, 0,
0513         rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
0514     SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
0515         RT700_SET_GAIN_AMIC_H,  RT700_SET_GAIN_AMIC_L,
0516         RT700_DIR_IN_SFT, 3, 0,
0517         rt700_set_amp_gain_get, rt700_set_amp_gain_put, mic_vol_tlv),
0518 };
0519 
0520 static int rt700_mux_get(struct snd_kcontrol *kcontrol,
0521             struct snd_ctl_elem_value *ucontrol)
0522 {
0523     struct snd_soc_component *component =
0524         snd_soc_dapm_kcontrol_component(kcontrol);
0525     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0526     unsigned int reg, val = 0, nid;
0527     int ret;
0528 
0529     if (strstr(ucontrol->id.name, "HPO Mux"))
0530         nid = RT700_HP_OUT;
0531     else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
0532         nid = RT700_MIXER_IN1;
0533     else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
0534         nid = RT700_MIXER_IN2;
0535     else
0536         return -EINVAL;
0537 
0538     /* vid = 0xf01 */
0539     reg = RT700_VERB_SET_CONNECT_SEL | nid;
0540     ret = regmap_read(rt700->regmap, reg, &val);
0541     if (ret < 0)
0542         return ret;
0543 
0544     ucontrol->value.enumerated.item[0] = val;
0545 
0546     return 0;
0547 }
0548 
0549 static int rt700_mux_put(struct snd_kcontrol *kcontrol,
0550             struct snd_ctl_elem_value *ucontrol)
0551 {
0552     struct snd_soc_component *component =
0553         snd_soc_dapm_kcontrol_component(kcontrol);
0554     struct snd_soc_dapm_context *dapm =
0555         snd_soc_dapm_kcontrol_dapm(kcontrol);
0556     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0557     struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
0558     unsigned int *item = ucontrol->value.enumerated.item;
0559     unsigned int val, val2 = 0, change, reg, nid;
0560     int ret;
0561 
0562     if (item[0] >= e->items)
0563         return -EINVAL;
0564 
0565     if (strstr(ucontrol->id.name, "HPO Mux"))
0566         nid = RT700_HP_OUT;
0567     else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
0568         nid = RT700_MIXER_IN1;
0569     else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
0570         nid = RT700_MIXER_IN2;
0571     else
0572         return -EINVAL;
0573 
0574     /* Verb ID = 0x701h */
0575     val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
0576 
0577     reg = RT700_VERB_SET_CONNECT_SEL | nid;
0578     ret = regmap_read(rt700->regmap, reg, &val2);
0579     if (ret < 0)
0580         return ret;
0581 
0582     if (val == val2)
0583         change = 0;
0584     else
0585         change = 1;
0586 
0587     if (change) {
0588         reg = RT700_VERB_SET_CONNECT_SEL | nid;
0589         regmap_write(rt700->regmap, reg, val);
0590     }
0591 
0592     snd_soc_dapm_mux_update_power(dapm, kcontrol,
0593                         item[0], e, NULL);
0594 
0595     return change;
0596 }
0597 
0598 static const char * const adc_mux_text[] = {
0599     "MIC2",
0600     "LINE1",
0601     "LINE2",
0602     "DMIC",
0603 };
0604 
0605 static SOC_ENUM_SINGLE_DECL(
0606     rt700_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
0607 
0608 static SOC_ENUM_SINGLE_DECL(
0609     rt700_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
0610 
0611 static const struct snd_kcontrol_new rt700_adc22_mux =
0612     SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt700_adc22_enum,
0613             rt700_mux_get, rt700_mux_put);
0614 
0615 static const struct snd_kcontrol_new rt700_adc23_mux =
0616     SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt700_adc23_enum,
0617             rt700_mux_get, rt700_mux_put);
0618 
0619 static const char * const out_mux_text[] = {
0620     "Front",
0621     "Surround",
0622 };
0623 
0624 static SOC_ENUM_SINGLE_DECL(
0625     rt700_hp_enum, SND_SOC_NOPM, 0, out_mux_text);
0626 
0627 static const struct snd_kcontrol_new rt700_hp_mux =
0628     SOC_DAPM_ENUM_EXT("HP Mux", rt700_hp_enum,
0629             rt700_mux_get, rt700_mux_put);
0630 
0631 static int rt700_dac_front_event(struct snd_soc_dapm_widget *w,
0632     struct snd_kcontrol *kcontrol, int event)
0633 {
0634     struct snd_soc_component *component =
0635         snd_soc_dapm_to_component(w->dapm);
0636     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0637 
0638     switch (event) {
0639     case SND_SOC_DAPM_POST_PMU:
0640         regmap_write(rt700->regmap,
0641             RT700_SET_STREAMID_DAC1, 0x10);
0642         break;
0643     case SND_SOC_DAPM_PRE_PMD:
0644         regmap_write(rt700->regmap,
0645             RT700_SET_STREAMID_DAC1, 0x00);
0646         break;
0647     }
0648     return 0;
0649 }
0650 
0651 static int rt700_dac_surround_event(struct snd_soc_dapm_widget *w,
0652     struct snd_kcontrol *kcontrol, int event)
0653 {
0654     struct snd_soc_component *component =
0655         snd_soc_dapm_to_component(w->dapm);
0656     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0657 
0658     switch (event) {
0659     case SND_SOC_DAPM_POST_PMU:
0660         regmap_write(rt700->regmap,
0661             RT700_SET_STREAMID_DAC2, 0x10);
0662         break;
0663     case SND_SOC_DAPM_PRE_PMD:
0664         regmap_write(rt700->regmap,
0665             RT700_SET_STREAMID_DAC2, 0x00);
0666         break;
0667     }
0668     return 0;
0669 }
0670 
0671 static int rt700_adc_09_event(struct snd_soc_dapm_widget *w,
0672     struct snd_kcontrol *kcontrol, int event)
0673 {
0674     struct snd_soc_component *component =
0675         snd_soc_dapm_to_component(w->dapm);
0676     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0677 
0678     switch (event) {
0679     case SND_SOC_DAPM_POST_PMU:
0680         regmap_write(rt700->regmap,
0681             RT700_SET_STREAMID_ADC1, 0x10);
0682         break;
0683     case SND_SOC_DAPM_PRE_PMD:
0684         regmap_write(rt700->regmap,
0685             RT700_SET_STREAMID_ADC1, 0x00);
0686         break;
0687     }
0688     return 0;
0689 }
0690 
0691 static int rt700_adc_08_event(struct snd_soc_dapm_widget *w,
0692     struct snd_kcontrol *kcontrol, int event)
0693 {
0694     struct snd_soc_component *component =
0695         snd_soc_dapm_to_component(w->dapm);
0696     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0697 
0698     switch (event) {
0699     case SND_SOC_DAPM_POST_PMU:
0700         regmap_write(rt700->regmap,
0701             RT700_SET_STREAMID_ADC2, 0x10);
0702         break;
0703     case SND_SOC_DAPM_PRE_PMD:
0704         regmap_write(rt700->regmap,
0705             RT700_SET_STREAMID_ADC2, 0x00);
0706         break;
0707     }
0708     return 0;
0709 }
0710 
0711 static int rt700_hpo_mux_event(struct snd_soc_dapm_widget *w,
0712     struct snd_kcontrol *kcontrol, int event)
0713 {
0714     struct snd_soc_component *component =
0715         snd_soc_dapm_to_component(w->dapm);
0716     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0717     unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
0718     unsigned int val_l;
0719 
0720     switch (event) {
0721     case SND_SOC_DAPM_POST_PMU:
0722         val_l = 0x00;
0723         regmap_write(rt700->regmap,
0724             RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
0725         break;
0726     case SND_SOC_DAPM_PRE_PMD:
0727         val_l = (1 << RT700_MUTE_SFT);
0728         regmap_write(rt700->regmap,
0729             RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
0730         usleep_range(50000, 55000);
0731         break;
0732     }
0733     return 0;
0734 }
0735 
0736 static int rt700_spk_pga_event(struct snd_soc_dapm_widget *w,
0737     struct snd_kcontrol *kcontrol, int event)
0738 {
0739     struct snd_soc_component *component =
0740         snd_soc_dapm_to_component(w->dapm);
0741     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0742     unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
0743     unsigned int val_l;
0744 
0745     switch (event) {
0746     case SND_SOC_DAPM_POST_PMU:
0747         val_l = 0x00;
0748         regmap_write(rt700->regmap,
0749             RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
0750         break;
0751     case SND_SOC_DAPM_PRE_PMD:
0752         val_l = (1 << RT700_MUTE_SFT);
0753         regmap_write(rt700->regmap,
0754             RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
0755         break;
0756     }
0757     return 0;
0758 }
0759 
0760 static const struct snd_soc_dapm_widget rt700_dapm_widgets[] = {
0761     SND_SOC_DAPM_OUTPUT("HP"),
0762     SND_SOC_DAPM_OUTPUT("SPK"),
0763     SND_SOC_DAPM_INPUT("DMIC1"),
0764     SND_SOC_DAPM_INPUT("DMIC2"),
0765     SND_SOC_DAPM_INPUT("MIC2"),
0766     SND_SOC_DAPM_INPUT("LINE1"),
0767     SND_SOC_DAPM_INPUT("LINE2"),
0768     SND_SOC_DAPM_DAC_E("DAC Front", NULL, SND_SOC_NOPM, 0, 0,
0769         rt700_dac_front_event,
0770         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0771     SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
0772         rt700_dac_surround_event,
0773         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0774     SND_SOC_DAPM_MUX_E("HPO Mux", SND_SOC_NOPM, 0, 0, &rt700_hp_mux,
0775         rt700_hpo_mux_event,
0776         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0777     SND_SOC_DAPM_PGA_E("SPK PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
0778         rt700_spk_pga_event,
0779         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0780     SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
0781         rt700_adc_09_event,
0782         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0783     SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
0784         rt700_adc_08_event,
0785         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
0786     SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
0787         &rt700_adc22_mux),
0788     SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
0789         &rt700_adc23_mux),
0790     SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
0791     SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
0792     SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
0793     SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
0794 };
0795 
0796 static const struct snd_soc_dapm_route rt700_audio_map[] = {
0797     {"DAC Front", NULL, "DP1RX"},
0798     {"DAC Surround", NULL, "DP3RX"},
0799     {"DP2TX", NULL, "ADC 09"},
0800     {"DP4TX", NULL, "ADC 08"},
0801     {"ADC 09", NULL, "ADC 22 Mux"},
0802     {"ADC 08", NULL, "ADC 23 Mux"},
0803     {"ADC 22 Mux", "DMIC", "DMIC1"},
0804     {"ADC 22 Mux", "LINE1", "LINE1"},
0805     {"ADC 22 Mux", "LINE2", "LINE2"},
0806     {"ADC 22 Mux", "MIC2", "MIC2"},
0807     {"ADC 23 Mux", "DMIC", "DMIC2"},
0808     {"ADC 23 Mux", "LINE1", "LINE1"},
0809     {"ADC 23 Mux", "LINE2", "LINE2"},
0810     {"ADC 23 Mux", "MIC2", "MIC2"},
0811     {"HPO Mux", "Front", "DAC Front"},
0812     {"HPO Mux", "Surround", "DAC Surround"},
0813     {"HP", NULL, "HPO Mux"},
0814     {"SPK PGA", NULL, "DAC Front"},
0815     {"SPK", NULL, "SPK PGA"},
0816 };
0817 
0818 static int rt700_probe(struct snd_soc_component *component)
0819 {
0820     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0821     int ret;
0822 
0823     rt700->component = component;
0824 
0825     ret = pm_runtime_resume(component->dev);
0826     if (ret < 0 && ret != -EACCES)
0827         return ret;
0828 
0829     return 0;
0830 }
0831 
0832 static int rt700_set_bias_level(struct snd_soc_component *component,
0833                 enum snd_soc_bias_level level)
0834 {
0835     struct snd_soc_dapm_context *dapm =
0836         snd_soc_component_get_dapm(component);
0837     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0838 
0839     switch (level) {
0840     case SND_SOC_BIAS_PREPARE:
0841         if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
0842             regmap_write(rt700->regmap,
0843                 RT700_SET_AUDIO_POWER_STATE,
0844                 AC_PWRST_D0);
0845         }
0846         break;
0847 
0848     case SND_SOC_BIAS_STANDBY:
0849         regmap_write(rt700->regmap,
0850             RT700_SET_AUDIO_POWER_STATE,
0851             AC_PWRST_D3);
0852         break;
0853 
0854     default:
0855         break;
0856     }
0857     dapm->bias_level = level;
0858     return 0;
0859 }
0860 
0861 static const struct snd_soc_component_driver soc_codec_dev_rt700 = {
0862     .probe = rt700_probe,
0863     .set_bias_level = rt700_set_bias_level,
0864     .controls = rt700_snd_controls,
0865     .num_controls = ARRAY_SIZE(rt700_snd_controls),
0866     .dapm_widgets = rt700_dapm_widgets,
0867     .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets),
0868     .dapm_routes = rt700_audio_map,
0869     .num_dapm_routes = ARRAY_SIZE(rt700_audio_map),
0870     .set_jack = rt700_set_jack_detect,
0871     .endianness = 1,
0872 };
0873 
0874 static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
0875                 int direction)
0876 {
0877     struct sdw_stream_data *stream;
0878 
0879     if (!sdw_stream)
0880         return 0;
0881 
0882     stream = kzalloc(sizeof(*stream), GFP_KERNEL);
0883     if (!stream)
0884         return -ENOMEM;
0885 
0886     stream->sdw_stream = sdw_stream;
0887 
0888     /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
0889     if (direction == SNDRV_PCM_STREAM_PLAYBACK)
0890         dai->playback_dma_data = stream;
0891     else
0892         dai->capture_dma_data = stream;
0893 
0894     return 0;
0895 }
0896 
0897 static void rt700_shutdown(struct snd_pcm_substream *substream,
0898                 struct snd_soc_dai *dai)
0899 {
0900     struct sdw_stream_data *stream;
0901 
0902     stream = snd_soc_dai_get_dma_data(dai, substream);
0903     snd_soc_dai_set_dma_data(dai, substream, NULL);
0904     kfree(stream);
0905 }
0906 
0907 static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
0908                     struct snd_pcm_hw_params *params,
0909                     struct snd_soc_dai *dai)
0910 {
0911     struct snd_soc_component *component = dai->component;
0912     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
0913     struct sdw_stream_config stream_config;
0914     struct sdw_port_config port_config;
0915     enum sdw_data_direction direction;
0916     struct sdw_stream_data *stream;
0917     int retval, port, num_channels;
0918     unsigned int val = 0;
0919 
0920     dev_dbg(dai->dev, "%s %s", __func__, dai->name);
0921     stream = snd_soc_dai_get_dma_data(dai, substream);
0922 
0923     if (!stream)
0924         return -EINVAL;
0925 
0926     if (!rt700->slave)
0927         return -EINVAL;
0928 
0929     /* SoundWire specific configuration */
0930     /* This code assumes port 1 for playback and port 2 for capture */
0931     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
0932         direction = SDW_DATA_DIR_RX;
0933         port = 1;
0934     } else {
0935         direction = SDW_DATA_DIR_TX;
0936         port = 2;
0937     }
0938 
0939     switch (dai->id) {
0940     case RT700_AIF1:
0941         break;
0942     case RT700_AIF2:
0943         port += 2;
0944         break;
0945     default:
0946         dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
0947         return -EINVAL;
0948     }
0949 
0950     stream_config.frame_rate = params_rate(params);
0951     stream_config.ch_count = params_channels(params);
0952     stream_config.bps = snd_pcm_format_width(params_format(params));
0953     stream_config.direction = direction;
0954 
0955     num_channels = params_channels(params);
0956     port_config.ch_mask = (1 << (num_channels)) - 1;
0957     port_config.num = port;
0958 
0959     retval = sdw_stream_add_slave(rt700->slave, &stream_config,
0960                     &port_config, 1, stream->sdw_stream);
0961     if (retval) {
0962         dev_err(dai->dev, "Unable to configure port\n");
0963         return retval;
0964     }
0965 
0966     if (params_channels(params) <= 16) {
0967         /* bit 3:0 Number of Channel */
0968         val |= (params_channels(params) - 1);
0969     } else {
0970         dev_err(component->dev, "Unsupported channels %d\n",
0971             params_channels(params));
0972         return -EINVAL;
0973     }
0974 
0975     switch (params_width(params)) {
0976     /* bit 6:4 Bits per Sample */
0977     case 8:
0978         break;
0979     case 16:
0980         val |= (0x1 << 4);
0981         break;
0982     case 20:
0983         val |= (0x2 << 4);
0984         break;
0985     case 24:
0986         val |= (0x3 << 4);
0987         break;
0988     case 32:
0989         val |= (0x4 << 4);
0990         break;
0991     default:
0992         return -EINVAL;
0993     }
0994 
0995     /* 48Khz */
0996     regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val);
0997     regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val);
0998 
0999     return retval;
1000 }
1001 
1002 static int rt700_pcm_hw_free(struct snd_pcm_substream *substream,
1003                 struct snd_soc_dai *dai)
1004 {
1005     struct snd_soc_component *component = dai->component;
1006     struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
1007     struct sdw_stream_data *stream =
1008         snd_soc_dai_get_dma_data(dai, substream);
1009 
1010     if (!rt700->slave)
1011         return -EINVAL;
1012 
1013     sdw_stream_remove_slave(rt700->slave, stream->sdw_stream);
1014     return 0;
1015 }
1016 
1017 #define RT700_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
1018 #define RT700_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1019             SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
1020 
1021 static const struct snd_soc_dai_ops rt700_ops = {
1022     .hw_params  = rt700_pcm_hw_params,
1023     .hw_free    = rt700_pcm_hw_free,
1024     .set_stream = rt700_set_sdw_stream,
1025     .shutdown   = rt700_shutdown,
1026 };
1027 
1028 static struct snd_soc_dai_driver rt700_dai[] = {
1029     {
1030         .name = "rt700-aif1",
1031         .id = RT700_AIF1,
1032         .playback = {
1033             .stream_name = "DP1 Playback",
1034             .channels_min = 1,
1035             .channels_max = 2,
1036             .rates = RT700_STEREO_RATES,
1037             .formats = RT700_FORMATS,
1038         },
1039         .capture = {
1040             .stream_name = "DP2 Capture",
1041             .channels_min = 1,
1042             .channels_max = 2,
1043             .rates = RT700_STEREO_RATES,
1044             .formats = RT700_FORMATS,
1045         },
1046         .ops = &rt700_ops,
1047     },
1048     {
1049         .name = "rt700-aif2",
1050         .id = RT700_AIF2,
1051         .playback = {
1052             .stream_name = "DP3 Playback",
1053             .channels_min = 1,
1054             .channels_max = 2,
1055             .rates = RT700_STEREO_RATES,
1056             .formats = RT700_FORMATS,
1057         },
1058         .capture = {
1059             .stream_name = "DP4 Capture",
1060             .channels_min = 1,
1061             .channels_max = 2,
1062             .rates = RT700_STEREO_RATES,
1063             .formats = RT700_FORMATS,
1064         },
1065         .ops = &rt700_ops,
1066     },
1067 };
1068 
1069 /* Bus clock frequency */
1070 #define RT700_CLK_FREQ_9600000HZ 9600000
1071 #define RT700_CLK_FREQ_12000000HZ 12000000
1072 #define RT700_CLK_FREQ_6000000HZ 6000000
1073 #define RT700_CLK_FREQ_4800000HZ 4800000
1074 #define RT700_CLK_FREQ_2400000HZ 2400000
1075 #define RT700_CLK_FREQ_12288000HZ 12288000
1076 
1077 int rt700_clock_config(struct device *dev)
1078 {
1079     struct rt700_priv *rt700 = dev_get_drvdata(dev);
1080     unsigned int clk_freq, value;
1081 
1082     clk_freq = (rt700->params.curr_dr_freq >> 1);
1083 
1084     switch (clk_freq) {
1085     case RT700_CLK_FREQ_12000000HZ:
1086         value = 0x0;
1087         break;
1088     case RT700_CLK_FREQ_6000000HZ:
1089         value = 0x1;
1090         break;
1091     case RT700_CLK_FREQ_9600000HZ:
1092         value = 0x2;
1093         break;
1094     case RT700_CLK_FREQ_4800000HZ:
1095         value = 0x3;
1096         break;
1097     case RT700_CLK_FREQ_2400000HZ:
1098         value = 0x4;
1099         break;
1100     case RT700_CLK_FREQ_12288000HZ:
1101         value = 0x5;
1102         break;
1103     default:
1104         return -EINVAL;
1105     }
1106 
1107     regmap_write(rt700->regmap, 0xe0, value);
1108     regmap_write(rt700->regmap, 0xf0, value);
1109 
1110     dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
1111 
1112     return 0;
1113 }
1114 
1115 int rt700_init(struct device *dev, struct regmap *sdw_regmap,
1116             struct regmap *regmap, struct sdw_slave *slave)
1117 
1118 {
1119     struct rt700_priv *rt700;
1120     int ret;
1121 
1122     rt700 = devm_kzalloc(dev, sizeof(*rt700), GFP_KERNEL);
1123     if (!rt700)
1124         return -ENOMEM;
1125 
1126     dev_set_drvdata(dev, rt700);
1127     rt700->slave = slave;
1128     rt700->sdw_regmap = sdw_regmap;
1129     rt700->regmap = regmap;
1130 
1131     mutex_init(&rt700->disable_irq_lock);
1132 
1133     INIT_DELAYED_WORK(&rt700->jack_detect_work,
1134               rt700_jack_detect_handler);
1135     INIT_DELAYED_WORK(&rt700->jack_btn_check_work,
1136               rt700_btn_check_handler);
1137 
1138     /*
1139      * Mark hw_init to false
1140      * HW init will be performed when device reports present
1141      */
1142     rt700->hw_init = false;
1143     rt700->first_hw_init = false;
1144 
1145     ret =  devm_snd_soc_register_component(dev,
1146                 &soc_codec_dev_rt700,
1147                 rt700_dai,
1148                 ARRAY_SIZE(rt700_dai));
1149 
1150     dev_dbg(&slave->dev, "%s\n", __func__);
1151 
1152     return ret;
1153 }
1154 
1155 int rt700_io_init(struct device *dev, struct sdw_slave *slave)
1156 {
1157     struct rt700_priv *rt700 = dev_get_drvdata(dev);
1158 
1159     rt700->disable_irq = false;
1160 
1161     if (rt700->hw_init)
1162         return 0;
1163 
1164     if (rt700->first_hw_init) {
1165         regcache_cache_only(rt700->regmap, false);
1166         regcache_cache_bypass(rt700->regmap, true);
1167     }
1168 
1169     /*
1170      * PM runtime is only enabled when a Slave reports as Attached
1171      */
1172     if (!rt700->first_hw_init) {
1173         /* set autosuspend parameters */
1174         pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
1175         pm_runtime_use_autosuspend(&slave->dev);
1176 
1177         /* update count of parent 'active' children */
1178         pm_runtime_set_active(&slave->dev);
1179 
1180         /* make sure the device does not suspend immediately */
1181         pm_runtime_mark_last_busy(&slave->dev);
1182 
1183         pm_runtime_enable(&slave->dev);
1184     }
1185 
1186     pm_runtime_get_noresume(&slave->dev);
1187 
1188     /* reset */
1189     regmap_write(rt700->regmap, 0xff01, 0x0000);
1190     regmap_write(rt700->regmap, 0x7520, 0x001a);
1191     regmap_write(rt700->regmap, 0x7420, 0xc003);
1192 
1193     /* power on */
1194     regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
1195     /* Set Pin Widget */
1196     regmap_write(rt700->regmap, RT700_SET_PIN_HP, 0x40);
1197     regmap_write(rt700->regmap, RT700_SET_PIN_SPK, 0x40);
1198     regmap_write(rt700->regmap, RT700_SET_EAPD_SPK, RT700_EAPD_HIGH);
1199     regmap_write(rt700->regmap, RT700_SET_PIN_DMIC1, 0x20);
1200     regmap_write(rt700->regmap, RT700_SET_PIN_DMIC2, 0x20);
1201     regmap_write(rt700->regmap, RT700_SET_PIN_MIC2, 0x20);
1202 
1203     /* Set Configuration Default */
1204     regmap_write(rt700->regmap, 0x4f12, 0x91);
1205     regmap_write(rt700->regmap, 0x4e12, 0xd6);
1206     regmap_write(rt700->regmap, 0x4d12, 0x11);
1207     regmap_write(rt700->regmap, 0x4c12, 0x20);
1208     regmap_write(rt700->regmap, 0x4f13, 0x91);
1209     regmap_write(rt700->regmap, 0x4e13, 0xd6);
1210     regmap_write(rt700->regmap, 0x4d13, 0x11);
1211     regmap_write(rt700->regmap, 0x4c13, 0x21);
1212 
1213     regmap_write(rt700->regmap, 0x4f19, 0x02);
1214     regmap_write(rt700->regmap, 0x4e19, 0xa1);
1215     regmap_write(rt700->regmap, 0x4d19, 0x90);
1216     regmap_write(rt700->regmap, 0x4c19, 0x80);
1217 
1218     /* Enable Line2 */
1219     regmap_write(rt700->regmap,  0x371b, 0x40);
1220     regmap_write(rt700->regmap,  0x731b, 0xb0);
1221     regmap_write(rt700->regmap,  0x839b, 0x00);
1222 
1223     /* Set index */
1224     rt700_index_write(rt700->regmap, 0x4a, 0x201b);
1225     rt700_index_write(rt700->regmap, 0x45, 0x5089);
1226     rt700_index_write(rt700->regmap, 0x6b, 0x5064);
1227     rt700_index_write(rt700->regmap, 0x48, 0xd249);
1228 
1229     /* Finish Initial Settings, set power to D3 */
1230     regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
1231 
1232     /*
1233      * if set_jack callback occurred early than io_init,
1234      * we set up the jack detection function now
1235      */
1236     if (rt700->hs_jack)
1237         rt700_jack_init(rt700);
1238 
1239     if (rt700->first_hw_init) {
1240         regcache_cache_bypass(rt700->regmap, false);
1241         regcache_mark_dirty(rt700->regmap);
1242     } else
1243         rt700->first_hw_init = true;
1244 
1245     /* Mark Slave initialization complete */
1246     rt700->hw_init = true;
1247 
1248     pm_runtime_mark_last_busy(&slave->dev);
1249     pm_runtime_put_autosuspend(&slave->dev);
1250 
1251     dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1252 
1253     return 0;
1254 }
1255 
1256 MODULE_DESCRIPTION("ASoC RT700 driver SDW");
1257 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1258 MODULE_LICENSE("GPL v2");
[ 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!