sound/soc/codecs/rt700.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // rt700.c -- rt700 ALSA SoC audio driver
   4 //
   5 // Copyright(c) 2019 Realtek Semiconductor Corp.
   6 //
   7 //
   8
   9 #include <linux/module.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/delay.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/pm.h>
  16 #include <linux/soundwire/sdw.h>
  17 #include <linux/regmap.h>
  18 #include <linux/slab.h>
  19 #include <sound/core.h>
  20 #include <sound/pcm.h>
  21 #include <sound/pcm_params.h>
  22 #include <sound/soc.h>
  23 #include <sound/soc-dapm.h>
  24 #include <sound/initval.h>
  25 #include <sound/tlv.h>
  26 #include <sound/hda_verbs.h>
  27 #include <sound/jack.h>
  28
  29 #include "rt700.h"
  30
  31 static int rt700_index_write(struct regmap *regmap,
  32                 unsigned int reg, unsigned int value)
  33 {
  34         int ret;
  35         unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
  36
  37         ret = regmap_write(regmap, addr, value);
  38         if (ret < 0)
  39                 pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
  40                         addr, value, ret);
  41
  42         return ret;
  43 }
  44
  45 static int rt700_index_read(struct regmap *regmap,
  46                 unsigned int reg, unsigned int *value)
  47 {
  48         int ret;
  49         unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
  50
  51         *value = 0;
  52         ret = regmap_read(regmap, addr, value);
  53         if (ret < 0)
  54                 pr_err("Failed to get private value: %06x => %04x ret=%d\n",
  55                         addr, *value, ret);
  56
  57         return ret;
  58 }
  59
  60 static unsigned int rt700_button_detect(struct rt700_priv *rt700)
  61 {
  62         unsigned int btn_type = 0, val80, val81;
  63         int ret;
  64
  65         ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE1, &val80);
  66         if (ret < 0)
  67                 goto read_error;
  68         ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE2, &val81);
  69         if (ret < 0)
  70                 goto read_error;
  71
  72         val80 &= 0x0381;
  73         val81 &= 0xff00;
  74
  75         switch (val80) {
  76         case 0x0200:
  77         case 0x0100:
  78         case 0x0080:
  79                 btn_type |= SND_JACK_BTN_0;
  80                 break;
  81         case 0x0001:
  82                 btn_type |= SND_JACK_BTN_3;
  83                 break;
  84         }
  85         switch (val81) {
  86         case 0x8000:
  87         case 0x4000:
  88         case 0x2000:
  89                 btn_type |= SND_JACK_BTN_1;
  90                 break;
  91         case 0x1000:
  92         case 0x0800:
  93         case 0x0400:
  94                 btn_type |= SND_JACK_BTN_2;
  95                 break;
  96         case 0x0200:
  97         case 0x0100:
  98                 btn_type |= SND_JACK_BTN_3;
  99                 break;
 100         }
 101 read_error:
 102         return btn_type;
 103 }
 104
 105 static int rt700_headset_detect(struct rt700_priv *rt700)
 106 {
 107         unsigned int buf, loop = 0;
 108         int ret;
 109         unsigned int jack_status = 0, reg;
 110
 111         ret = rt700_index_read(rt700->regmap,
 112                                         RT700_COMBO_JACK_AUTO_CTL2, &buf);
 113         if (ret < 0)
 114                 goto io_error;
 115
 116         while (loop < 500 &&
 117                 (buf & RT700_COMBOJACK_AUTO_DET_STATUS) == 0) {
 118                 loop++;
 119
 120                 usleep_range(9000, 10000);
 121                 ret = rt700_index_read(rt700->regmap,
 122                                         RT700_COMBO_JACK_AUTO_CTL2, &buf);
 123                 if (ret < 0)
 124                         goto io_error;
 125
 126                 reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
 127                 ret = regmap_read(rt700->regmap, reg, &jack_status);
 128                 if ((jack_status & (1 << 31)) == 0)
 129                         goto remove_error;
 130         }
 131
 132         if (loop >= 500)
 133                 goto to_error;
 134
 135         if (buf & RT700_COMBOJACK_AUTO_DET_TRS)
 136                 rt700->jack_type = SND_JACK_HEADPHONE;
 137         else if ((buf & RT700_COMBOJACK_AUTO_DET_CTIA) ||
 138                 (buf & RT700_COMBOJACK_AUTO_DET_OMTP))
 139                 rt700->jack_type = SND_JACK_HEADSET;
 140
 141         return 0;
 142
 143 to_error:
 144         ret = -ETIMEDOUT;
 145         pr_err_ratelimited("Time-out error in %s\n", __func__);
 146         return ret;
 147 io_error:
 148         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 149         return ret;
 150 remove_error:
 151         pr_err_ratelimited("Jack removal in %s\n", __func__);
 152         return -ENODEV;
 153 }
 154
 155 static void rt700_jack_detect_handler(struct work_struct *work)
 156 {
 157         struct rt700_priv *rt700 =
 158                 container_of(work, struct rt700_priv, jack_detect_work.work);
 159         int btn_type = 0, ret;
 160         unsigned int jack_status = 0, reg;
 161
 162         if (!rt700->hs_jack)
 163                 return;
 164
 165         if (!rt700->component->card || !rt700->component->card->instantiated)
 166                 return;
 167
 168         reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
 169         ret = regmap_read(rt700->regmap, reg, &jack_status);
 170         if (ret < 0)
 171                 goto io_error;
 172
 173         /* pin attached */
 174         if (jack_status & (1 << 31)) {
 175                 /* jack in */
 176                 if (rt700->jack_type == 0) {
 177                         ret = rt700_headset_detect(rt700);
 178                         if (ret < 0)
 179                                 return;
 180                         if (rt700->jack_type == SND_JACK_HEADSET)
 181                                 btn_type = rt700_button_detect(rt700);
 182                 } else if (rt700->jack_type == SND_JACK_HEADSET) {
 183                         /* jack is already in, report button event */
 184                         btn_type = rt700_button_detect(rt700);
 185                 }
 186         } else {
 187                 /* jack out */
 188                 rt700->jack_type = 0;
 189         }
 190
 191         dev_dbg(&rt700->slave->dev,
 192                 "in %s, jack_type=0x%x\n", __func__, rt700->jack_type);
 193         dev_dbg(&rt700->slave->dev,
 194                 "in %s, btn_type=0x%x\n", __func__, btn_type);
 195
 196         snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
 197                         SND_JACK_HEADSET |
 198                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 199                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 200
 201         if (btn_type) {
 202                 /* button released */
 203                 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
 204                         SND_JACK_HEADSET |
 205                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 206                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 207
 208                 mod_delayed_work(system_power_efficient_wq,
 209                         &rt700->jack_btn_check_work, msecs_to_jiffies(200));
 210         }
 211
 212         return;
 213
 214 io_error:
 215         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 216 }
 217
 218 static void rt700_btn_check_handler(struct work_struct *work)
 219 {
 220         struct rt700_priv *rt700 = container_of(work, struct rt700_priv,
 221                 jack_btn_check_work.work);
 222         int btn_type = 0, ret;
 223         unsigned int jack_status = 0, reg;
 224
 225         reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
 226         ret = regmap_read(rt700->regmap, reg, &jack_status);
 227         if (ret < 0)
 228                 goto io_error;
 229
 230         /* pin attached */
 231         if (jack_status & (1 << 31)) {
 232                 if (rt700->jack_type == SND_JACK_HEADSET) {
 233                         /* jack is already in, report button event */
 234                         btn_type = rt700_button_detect(rt700);
 235                 }
 236         } else {
 237                 rt700->jack_type = 0;
 238         }
 239
 240         /* cbj comparator */
 241         ret = rt700_index_read(rt700->regmap, RT700_COMBO_JACK_AUTO_CTL2, &reg);
 242         if (ret < 0)
 243                 goto io_error;
 244
 245         if ((reg & 0xf0) == 0xf0)
 246                 btn_type = 0;
 247
 248         dev_dbg(&rt700->slave->dev,
 249                 "%s, btn_type=0x%x\n",  __func__, btn_type);
 250         snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
 251                         SND_JACK_HEADSET |
 252                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 253                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 254
 255         if (btn_type) {
 256                 /* button released */
 257                 snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
 258                         SND_JACK_HEADSET |
 259                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 260                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 261
 262                 mod_delayed_work(system_power_efficient_wq,
 263                         &rt700->jack_btn_check_work, msecs_to_jiffies(200));
 264         }
 265
 266         return;
 267
 268 io_error:
 269         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 270 }
 271
 272 static void rt700_jack_init(struct rt700_priv *rt700)
 273 {
 274         struct snd_soc_dapm_context *dapm =
 275                 snd_soc_component_get_dapm(rt700->component);
 276
 277         /* power on */
 278         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 279                 regmap_write(rt700->regmap,
 280                         RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
 281
 282         if (rt700->hs_jack) {
 283                 /* Enable Jack Detection */
 284                 regmap_write(rt700->regmap,
 285                         RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x82);
 286                 regmap_write(rt700->regmap,
 287                         RT700_SET_HP_UNSOLICITED_ENABLE, 0x81);
 288                 regmap_write(rt700->regmap,
 289                         RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x83);
 290                 rt700_index_write(rt700->regmap, 0x10, 0x2420);
 291                 rt700_index_write(rt700->regmap, 0x19, 0x2e11);
 292
 293                 dev_dbg(&rt700->slave->dev, "in %s enable\n", __func__);
 294
 295                 mod_delayed_work(system_power_efficient_wq,
 296                         &rt700->jack_detect_work, msecs_to_jiffies(250));
 297         } else {
 298                 regmap_write(rt700->regmap,
 299                         RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x00);
 300                 regmap_write(rt700->regmap,
 301                         RT700_SET_HP_UNSOLICITED_ENABLE, 0x00);
 302                 regmap_write(rt700->regmap,
 303                         RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x00);
 304
 305                 dev_dbg(&rt700->slave->dev, "in %s disable\n", __func__);
 306         }
 307
 308         /* power off */
 309         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 310                 regmap_write(rt700->regmap,
 311                         RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
 312 }
 313
 314 static int rt700_set_jack_detect(struct snd_soc_component *component,
 315         struct snd_soc_jack *hs_jack, void *data)
 316 {
 317         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 318         int ret;
 319
 320         rt700->hs_jack = hs_jack;
 321
 322         ret = pm_runtime_resume_and_get(component->dev);
 323         if (ret < 0) {
 324                 if (ret != -EACCES) {
 325                         dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
 326                         return ret;
 327                 }
 328
 329                 /* pm_runtime not enabled yet */
 330                 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
 331                 return 0;
 332         }
 333
 334         rt700_jack_init(rt700);
 335
 336         pm_runtime_mark_last_busy(component->dev);
 337         pm_runtime_put_autosuspend(component->dev);
 338
 339         return 0;
 340 }
 341
 342 static void rt700_get_gain(struct rt700_priv *rt700, unsigned int addr_h,
 343                                 unsigned int addr_l, unsigned int val_h,
 344                                 unsigned int *r_val, unsigned int *l_val)
 345 {
 346         /* R Channel */
 347         *r_val = (val_h << 8);
 348         regmap_read(rt700->regmap, addr_l, r_val);
 349
 350         /* L Channel */
 351         val_h |= 0x20;
 352         *l_val = (val_h << 8);
 353         regmap_read(rt700->regmap, addr_h, l_val);
 354 }
 355
 356 /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
 357 static int rt700_set_amp_gain_put(struct snd_kcontrol *kcontrol,
 358                 struct snd_ctl_elem_value *ucontrol)
 359 {
 360         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 361         struct snd_soc_dapm_context *dapm =
 362                 snd_soc_component_get_dapm(component);
 363         struct soc_mixer_control *mc =
 364                 (struct soc_mixer_control *)kcontrol->private_value;
 365         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 366         unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
 367         unsigned int read_ll, read_rl;
 368         int i;
 369
 370         /* Can't use update bit function, so read the original value first */
 371         addr_h = mc->reg;
 372         addr_l = mc->rreg;
 373         if (mc->shift == RT700_DIR_OUT_SFT) /* output */
 374                 val_h = 0x80;
 375         else /* input */
 376                 val_h = 0x0;
 377
 378         rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
 379
 380         /* L Channel */
 381         if (mc->invert) {
 382                 /* for mute */
 383                 val_ll = (mc->max - ucontrol->value.integer.value[0]) << 7;
 384                 /* keep gain */
 385                 read_ll = read_ll & 0x7f;
 386                 val_ll |= read_ll;
 387         } else {
 388                 /* for gain */
 389                 val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
 390                 if (val_ll > mc->max)
 391                         val_ll = mc->max;
 392                 /* keep mute status */
 393                 read_ll = read_ll & 0x80;
 394                 val_ll |= read_ll;
 395         }
 396
 397         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 398                 regmap_write(rt700->regmap,
 399                                 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
 400
 401         /* R Channel */
 402         if (mc->invert) {
 403                 /* for mute */
 404                 val_lr = (mc->max - ucontrol->value.integer.value[1]) << 7;
 405                 /* keep gain */
 406                 read_rl = read_rl & 0x7f;
 407                 val_lr |= read_rl;
 408         } else {
 409                 /* for gain */
 410                 val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
 411                 if (val_lr > mc->max)
 412                         val_lr = mc->max;
 413                 /* keep mute status */
 414                 read_rl = read_rl & 0x80;
 415                 val_lr |= read_rl;
 416         }
 417
 418         for (i = 0; i < 3; i++) { /* retry 3 times at most */
 419                 if (val_ll == val_lr) {
 420                         /* Set both L/R channels at the same time */
 421                         val_h = (1 << mc->shift) | (3 << 4);
 422                         regmap_write(rt700->regmap,
 423                                 addr_h, (val_h << 8 | val_ll));
 424                         regmap_write(rt700->regmap,
 425                                 addr_l, (val_h << 8 | val_ll));
 426                 } else {
 427                         /* Lch*/
 428                         val_h = (1 << mc->shift) | (1 << 5);
 429                         regmap_write(rt700->regmap,
 430                                 addr_h, (val_h << 8 | val_ll));
 431
 432                         /* Rch */
 433                         val_h = (1 << mc->shift) | (1 << 4);
 434                         regmap_write(rt700->regmap,
 435                                 addr_l, (val_h << 8 | val_lr));
 436                 }
 437                 /* check result */
 438                 if (mc->shift == RT700_DIR_OUT_SFT) /* output */
 439                         val_h = 0x80;
 440                 else /* input */
 441                         val_h = 0x0;
 442
 443                 rt700_get_gain(rt700, addr_h, addr_l, val_h,
 444                                         &read_rl, &read_ll);
 445                 if (read_rl == val_lr && read_ll == val_ll)
 446                         break;
 447         }
 448
 449         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 450                 regmap_write(rt700->regmap,
 451                                 RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
 452         return 0;
 453 }
 454
 455 static int rt700_set_amp_gain_get(struct snd_kcontrol *kcontrol,
 456                 struct snd_ctl_elem_value *ucontrol)
 457 {
 458         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 459         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 460         struct soc_mixer_control *mc =
 461                 (struct soc_mixer_control *)kcontrol->private_value;
 462         unsigned int addr_h, addr_l, val_h;
 463         unsigned int read_ll, read_rl;
 464
 465         addr_h = mc->reg;
 466         addr_l = mc->rreg;
 467         if (mc->shift == RT700_DIR_OUT_SFT) /* output */
 468                 val_h = 0x80;
 469         else /* input */
 470                 val_h = 0x0;
 471
 472         rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
 473
 474         if (mc->invert) {
 475                 /* for mute status */
 476                 read_ll = !((read_ll & 0x80) >> RT700_MUTE_SFT);
 477                 read_rl = !((read_rl & 0x80) >> RT700_MUTE_SFT);
 478         } else {
 479                 /* for gain */
 480                 read_ll = read_ll & 0x7f;
 481                 read_rl = read_rl & 0x7f;
 482         }
 483         ucontrol->value.integer.value[0] = read_ll;
 484         ucontrol->value.integer.value[1] = read_rl;
 485
 486         return 0;
 487 }
 488
 489 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
 490 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
 491 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
 492
 493 static const struct snd_kcontrol_new rt700_snd_controls[] = {
 494         SOC_DOUBLE_R_EXT_TLV("DAC Front Playback Volume",
 495                 RT700_SET_GAIN_DAC1_H, RT700_SET_GAIN_DAC1_L,
 496                 RT700_DIR_OUT_SFT, 0x57, 0,
 497                 rt700_set_amp_gain_get, rt700_set_amp_gain_put, out_vol_tlv),
 498         SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
 499                 RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
 500                 RT700_DIR_IN_SFT, 1, 1,
 501                 rt700_set_amp_gain_get, rt700_set_amp_gain_put),
 502         SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
 503                 RT700_SET_GAIN_ADC1_H,  RT700_SET_GAIN_ADC1_L,
 504                 RT700_DIR_IN_SFT, 1, 1,
 505                 rt700_set_amp_gain_get, rt700_set_amp_gain_put),
 506         SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
 507                 RT700_SET_GAIN_ADC2_H,  RT700_SET_GAIN_ADC2_L,
 508                 RT700_DIR_IN_SFT, 0x3f, 0,
 509                 rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
 510         SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
 511                 RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
 512                 RT700_DIR_IN_SFT, 0x3f, 0,
 513                 rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
 514         SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
 515                 RT700_SET_GAIN_AMIC_H,  RT700_SET_GAIN_AMIC_L,
 516                 RT700_DIR_IN_SFT, 3, 0,
 517                 rt700_set_amp_gain_get, rt700_set_amp_gain_put, mic_vol_tlv),
 518 };
 519
 520 static int rt700_mux_get(struct snd_kcontrol *kcontrol,
 521                         struct snd_ctl_elem_value *ucontrol)
 522 {
 523         struct snd_soc_component *component =
 524                 snd_soc_dapm_kcontrol_component(kcontrol);
 525         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 526         unsigned int reg, val = 0, nid;
 527         int ret;
 528
 529         if (strstr(ucontrol->id.name, "HPO Mux"))
 530                 nid = RT700_HP_OUT;
 531         else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 532                 nid = RT700_MIXER_IN1;
 533         else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 534                 nid = RT700_MIXER_IN2;
 535         else
 536                 return -EINVAL;
 537
 538         /* vid = 0xf01 */
 539         reg = RT700_VERB_SET_CONNECT_SEL | nid;
 540         ret = regmap_read(rt700->regmap, reg, &val);
 541         if (ret < 0)
 542                 return ret;
 543
 544         ucontrol->value.enumerated.item[0] = val;
 545
 546         return 0;
 547 }
 548
 549 static int rt700_mux_put(struct snd_kcontrol *kcontrol,
 550                         struct snd_ctl_elem_value *ucontrol)
 551 {
 552         struct snd_soc_component *component =
 553                 snd_soc_dapm_kcontrol_component(kcontrol);
 554         struct snd_soc_dapm_context *dapm =
 555                 snd_soc_dapm_kcontrol_dapm(kcontrol);
 556         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 557         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 558         unsigned int *item = ucontrol->value.enumerated.item;
 559         unsigned int val, val2 = 0, change, reg, nid;
 560         int ret;
 561
 562         if (item[0] >= e->items)
 563                 return -EINVAL;
 564
 565         if (strstr(ucontrol->id.name, "HPO Mux"))
 566                 nid = RT700_HP_OUT;
 567         else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 568                 nid = RT700_MIXER_IN1;
 569         else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 570                 nid = RT700_MIXER_IN2;
 571         else
 572                 return -EINVAL;
 573
 574         /* Verb ID = 0x701h */
 575         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
 576
 577         reg = RT700_VERB_SET_CONNECT_SEL | nid;
 578         ret = regmap_read(rt700->regmap, reg, &val2);
 579         if (ret < 0)
 580                 return ret;
 581
 582         if (val == val2)
 583                 change = 0;
 584         else
 585                 change = 1;
 586
 587         if (change) {
 588                 reg = RT700_VERB_SET_CONNECT_SEL | nid;
 589                 regmap_write(rt700->regmap, reg, val);
 590         }
 591
 592         snd_soc_dapm_mux_update_power(dapm, kcontrol,
 593                                                 item[0], e, NULL);
 594
 595         return change;
 596 }
 597
 598 static const char * const adc_mux_text[] = {
 599         "MIC2",
 600         "LINE1",
 601         "LINE2",
 602         "DMIC",
 603 };
 604
 605 static SOC_ENUM_SINGLE_DECL(
 606         rt700_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
 607
 608 static SOC_ENUM_SINGLE_DECL(
 609         rt700_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
 610
 611 static const struct snd_kcontrol_new rt700_adc22_mux =
 612         SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt700_adc22_enum,
 613                         rt700_mux_get, rt700_mux_put);
 614
 615 static const struct snd_kcontrol_new rt700_adc23_mux =
 616         SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt700_adc23_enum,
 617                         rt700_mux_get, rt700_mux_put);
 618
 619 static const char * const out_mux_text[] = {
 620         "Front",
 621         "Surround",
 622 };
 623
 624 static SOC_ENUM_SINGLE_DECL(
 625         rt700_hp_enum, SND_SOC_NOPM, 0, out_mux_text);
 626
 627 static const struct snd_kcontrol_new rt700_hp_mux =
 628         SOC_DAPM_ENUM_EXT("HP Mux", rt700_hp_enum,
 629                         rt700_mux_get, rt700_mux_put);
 630
 631 static int rt700_dac_front_event(struct snd_soc_dapm_widget *w,
 632         struct snd_kcontrol *kcontrol, int event)
 633 {
 634         struct snd_soc_component *component =
 635                 snd_soc_dapm_to_component(w->dapm);
 636         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 637
 638         switch (event) {
 639         case SND_SOC_DAPM_POST_PMU:
 640                 regmap_write(rt700->regmap,
 641                         RT700_SET_STREAMID_DAC1, 0x10);
 642                 break;
 643         case SND_SOC_DAPM_PRE_PMD:
 644                 regmap_write(rt700->regmap,
 645                         RT700_SET_STREAMID_DAC1, 0x00);
 646                 break;
 647         }
 648         return 0;
 649 }
 650
 651 static int rt700_dac_surround_event(struct snd_soc_dapm_widget *w,
 652         struct snd_kcontrol *kcontrol, int event)
 653 {
 654         struct snd_soc_component *component =
 655                 snd_soc_dapm_to_component(w->dapm);
 656         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 657
 658         switch (event) {
 659         case SND_SOC_DAPM_POST_PMU:
 660                 regmap_write(rt700->regmap,
 661                         RT700_SET_STREAMID_DAC2, 0x10);
 662                 break;
 663         case SND_SOC_DAPM_PRE_PMD:
 664                 regmap_write(rt700->regmap,
 665                         RT700_SET_STREAMID_DAC2, 0x00);
 666                 break;
 667         }
 668         return 0;
 669 }
 670
 671 static int rt700_adc_09_event(struct snd_soc_dapm_widget *w,
 672         struct snd_kcontrol *kcontrol, int event)
 673 {
 674         struct snd_soc_component *component =
 675                 snd_soc_dapm_to_component(w->dapm);
 676         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 677
 678         switch (event) {
 679         case SND_SOC_DAPM_POST_PMU:
 680                 regmap_write(rt700->regmap,
 681                         RT700_SET_STREAMID_ADC1, 0x10);
 682                 break;
 683         case SND_SOC_DAPM_PRE_PMD:
 684                 regmap_write(rt700->regmap,
 685                         RT700_SET_STREAMID_ADC1, 0x00);
 686                 break;
 687         }
 688         return 0;
 689 }
 690
 691 static int rt700_adc_08_event(struct snd_soc_dapm_widget *w,
 692         struct snd_kcontrol *kcontrol, int event)
 693 {
 694         struct snd_soc_component *component =
 695                 snd_soc_dapm_to_component(w->dapm);
 696         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 697
 698         switch (event) {
 699         case SND_SOC_DAPM_POST_PMU:
 700                 regmap_write(rt700->regmap,
 701                         RT700_SET_STREAMID_ADC2, 0x10);
 702                 break;
 703         case SND_SOC_DAPM_PRE_PMD:
 704                 regmap_write(rt700->regmap,
 705                         RT700_SET_STREAMID_ADC2, 0x00);
 706                 break;
 707         }
 708         return 0;
 709 }
 710
 711 static int rt700_hpo_mux_event(struct snd_soc_dapm_widget *w,
 712         struct snd_kcontrol *kcontrol, int event)
 713 {
 714         struct snd_soc_component *component =
 715                 snd_soc_dapm_to_component(w->dapm);
 716         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 717         unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
 718         unsigned int val_l;
 719
 720         switch (event) {
 721         case SND_SOC_DAPM_POST_PMU:
 722                 val_l = 0x00;
 723                 regmap_write(rt700->regmap,
 724                         RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
 725                 break;
 726         case SND_SOC_DAPM_PRE_PMD:
 727                 val_l = (1 << RT700_MUTE_SFT);
 728                 regmap_write(rt700->regmap,
 729                         RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
 730                 usleep_range(50000, 55000);
 731                 break;
 732         }
 733         return 0;
 734 }
 735
 736 static int rt700_spk_pga_event(struct snd_soc_dapm_widget *w,
 737         struct snd_kcontrol *kcontrol, int event)
 738 {
 739         struct snd_soc_component *component =
 740                 snd_soc_dapm_to_component(w->dapm);
 741         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 742         unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
 743         unsigned int val_l;
 744
 745         switch (event) {
 746         case SND_SOC_DAPM_POST_PMU:
 747                 val_l = 0x00;
 748                 regmap_write(rt700->regmap,
 749                         RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
 750                 break;
 751         case SND_SOC_DAPM_PRE_PMD:
 752                 val_l = (1 << RT700_MUTE_SFT);
 753                 regmap_write(rt700->regmap,
 754                         RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
 755                 break;
 756         }
 757         return 0;
 758 }
 759
 760 static const struct snd_soc_dapm_widget rt700_dapm_widgets[] = {
 761         SND_SOC_DAPM_OUTPUT("HP"),
 762         SND_SOC_DAPM_OUTPUT("SPK"),
 763         SND_SOC_DAPM_INPUT("DMIC1"),
 764         SND_SOC_DAPM_INPUT("DMIC2"),
 765         SND_SOC_DAPM_INPUT("MIC2"),
 766         SND_SOC_DAPM_INPUT("LINE1"),
 767         SND_SOC_DAPM_INPUT("LINE2"),
 768         SND_SOC_DAPM_DAC_E("DAC Front", NULL, SND_SOC_NOPM, 0, 0,
 769                 rt700_dac_front_event,
 770                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 771         SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
 772                 rt700_dac_surround_event,
 773                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 774         SND_SOC_DAPM_MUX_E("HPO Mux", SND_SOC_NOPM, 0, 0, &rt700_hp_mux,
 775                 rt700_hpo_mux_event,
 776                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 777         SND_SOC_DAPM_PGA_E("SPK PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
 778                 rt700_spk_pga_event,
 779                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 780         SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
 781                 rt700_adc_09_event,
 782                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 783         SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
 784                 rt700_adc_08_event,
 785                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 786         SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
 787                 &rt700_adc22_mux),
 788         SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
 789                 &rt700_adc23_mux),
 790         SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
 791         SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
 792         SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
 793         SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
 794 };
 795
 796 static const struct snd_soc_dapm_route rt700_audio_map[] = {
 797         {"DAC Front", NULL, "DP1RX"},
 798         {"DAC Surround", NULL, "DP3RX"},
 799         {"DP2TX", NULL, "ADC 09"},
 800         {"DP4TX", NULL, "ADC 08"},
 801         {"ADC 09", NULL, "ADC 22 Mux"},
 802         {"ADC 08", NULL, "ADC 23 Mux"},
 803         {"ADC 22 Mux", "DMIC", "DMIC1"},
 804         {"ADC 22 Mux", "LINE1", "LINE1"},
 805         {"ADC 22 Mux", "LINE2", "LINE2"},
 806         {"ADC 22 Mux", "MIC2", "MIC2"},
 807         {"ADC 23 Mux", "DMIC", "DMIC2"},
 808         {"ADC 23 Mux", "LINE1", "LINE1"},
 809         {"ADC 23 Mux", "LINE2", "LINE2"},
 810         {"ADC 23 Mux", "MIC2", "MIC2"},
 811         {"HPO Mux", "Front", "DAC Front"},
 812         {"HPO Mux", "Surround", "DAC Surround"},
 813         {"HP", NULL, "HPO Mux"},
 814         {"SPK PGA", NULL, "DAC Front"},
 815         {"SPK", NULL, "SPK PGA"},
 816 };
 817
 818 static int rt700_probe(struct snd_soc_component *component)
 819 {
 820         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 821
 822         rt700->component = component;
 823
 824         return 0;
 825 }
 826
 827 static int rt700_set_bias_level(struct snd_soc_component *component,
 828                                 enum snd_soc_bias_level level)
 829 {
 830         struct snd_soc_dapm_context *dapm =
 831                 snd_soc_component_get_dapm(component);
 832         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 833
 834         switch (level) {
 835         case SND_SOC_BIAS_PREPARE:
 836                 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
 837                         regmap_write(rt700->regmap,
 838                                 RT700_SET_AUDIO_POWER_STATE,
 839                                 AC_PWRST_D0);
 840                 }
 841                 break;
 842
 843         case SND_SOC_BIAS_STANDBY:
 844                 regmap_write(rt700->regmap,
 845                         RT700_SET_AUDIO_POWER_STATE,
 846                         AC_PWRST_D3);
 847                 break;
 848
 849         default:
 850                 break;
 851         }
 852         dapm->bias_level = level;
 853         return 0;
 854 }
 855
 856 static const struct snd_soc_component_driver soc_codec_dev_rt700 = {
 857         .probe = rt700_probe,
 858         .set_bias_level = rt700_set_bias_level,
 859         .controls = rt700_snd_controls,
 860         .num_controls = ARRAY_SIZE(rt700_snd_controls),
 861         .dapm_widgets = rt700_dapm_widgets,
 862         .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets),
 863         .dapm_routes = rt700_audio_map,
 864         .num_dapm_routes = ARRAY_SIZE(rt700_audio_map),
 865         .set_jack = rt700_set_jack_detect,
 866         .endianness = 1,
 867 };
 868
 869 static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
 870                                 int direction)
 871 {
 872         struct sdw_stream_data *stream;
 873
 874         if (!sdw_stream)
 875                 return 0;
 876
 877         stream = kzalloc(sizeof(*stream), GFP_KERNEL);
 878         if (!stream)
 879                 return -ENOMEM;
 880
 881         stream->sdw_stream = sdw_stream;
 882
 883         /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
 884         if (direction == SNDRV_PCM_STREAM_PLAYBACK)
 885                 dai->playback_dma_data = stream;
 886         else
 887                 dai->capture_dma_data = stream;
 888
 889         return 0;
 890 }
 891
 892 static void rt700_shutdown(struct snd_pcm_substream *substream,
 893                                 struct snd_soc_dai *dai)
 894 {
 895         struct sdw_stream_data *stream;
 896
 897         stream = snd_soc_dai_get_dma_data(dai, substream);
 898         snd_soc_dai_set_dma_data(dai, substream, NULL);
 899         kfree(stream);
 900 }
 901
 902 static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
 903                                         struct snd_pcm_hw_params *params,
 904                                         struct snd_soc_dai *dai)
 905 {
 906         struct snd_soc_component *component = dai->component;
 907         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 908         struct sdw_stream_config stream_config;
 909         struct sdw_port_config port_config;
 910         enum sdw_data_direction direction;
 911         struct sdw_stream_data *stream;
 912         int retval, port, num_channels;
 913         unsigned int val = 0;
 914
 915         dev_dbg(dai->dev, "%s %s", __func__, dai->name);
 916         stream = snd_soc_dai_get_dma_data(dai, substream);
 917
 918         if (!stream)
 919                 return -EINVAL;
 920
 921         if (!rt700->slave)
 922                 return -EINVAL;
 923
 924         /* SoundWire specific configuration */
 925         /* This code assumes port 1 for playback and port 2 for capture */
 926         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 927                 direction = SDW_DATA_DIR_RX;
 928                 port = 1;
 929         } else {
 930                 direction = SDW_DATA_DIR_TX;
 931                 port = 2;
 932         }
 933
 934         switch (dai->id) {
 935         case RT700_AIF1:
 936                 break;
 937         case RT700_AIF2:
 938                 port += 2;
 939                 break;
 940         default:
 941                 dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
 942                 return -EINVAL;
 943         }
 944
 945         stream_config.frame_rate = params_rate(params);
 946         stream_config.ch_count = params_channels(params);
 947         stream_config.bps = snd_pcm_format_width(params_format(params));
 948         stream_config.direction = direction;
 949
 950         num_channels = params_channels(params);
 951         port_config.ch_mask = (1 << (num_channels)) - 1;
 952         port_config.num = port;
 953
 954         retval = sdw_stream_add_slave(rt700->slave, &stream_config,
 955                                         &port_config, 1, stream->sdw_stream);
 956         if (retval) {
 957                 dev_err(dai->dev, "Unable to configure port\n");
 958                 return retval;
 959         }
 960
 961         if (params_channels(params) <= 16) {
 962                 /* bit 3:0 Number of Channel */
 963                 val |= (params_channels(params) - 1);
 964         } else {
 965                 dev_err(component->dev, "Unsupported channels %d\n",
 966                         params_channels(params));
 967                 return -EINVAL;
 968         }
 969
 970         switch (params_width(params)) {
 971         /* bit 6:4 Bits per Sample */
 972         case 8:
 973                 break;
 974         case 16:
 975                 val |= (0x1 << 4);
 976                 break;
 977         case 20:
 978                 val |= (0x2 << 4);
 979                 break;
 980         case 24:
 981                 val |= (0x3 << 4);
 982                 break;
 983         case 32:
 984                 val |= (0x4 << 4);
 985                 break;
 986         default:
 987                 return -EINVAL;
 988         }
 989
 990         /* 48Khz */
 991         regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val);
 992         regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val);
 993
 994         return retval;
 995 }
 996
 997 static int rt700_pcm_hw_free(struct snd_pcm_substream *substream,
 998                                 struct snd_soc_dai *dai)
 999 {
1000         struct snd_soc_component *component = dai->component;
1001         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
1002         struct sdw_stream_data *stream =
1003                 snd_soc_dai_get_dma_data(dai, substream);
1004
1005         if (!rt700->slave)
1006                 return -EINVAL;
1007
1008         sdw_stream_remove_slave(rt700->slave, stream->sdw_stream);
1009         return 0;
1010 }
1011
1012 #define RT700_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
1013 #define RT700_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1014                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
1015
1016 static const struct snd_soc_dai_ops rt700_ops = {
1017         .hw_params      = rt700_pcm_hw_params,
1018         .hw_free        = rt700_pcm_hw_free,
1019         .set_stream     = rt700_set_sdw_stream,
1020         .shutdown       = rt700_shutdown,
1021 };
1022
1023 static struct snd_soc_dai_driver rt700_dai[] = {
1024         {
1025                 .name = "rt700-aif1",
1026                 .id = RT700_AIF1,
1027                 .playback = {
1028                         .stream_name = "DP1 Playback",
1029                         .channels_min = 1,
1030                         .channels_max = 2,
1031                         .rates = RT700_STEREO_RATES,
1032                         .formats = RT700_FORMATS,
1033                 },
1034                 .capture = {
1035                         .stream_name = "DP2 Capture",
1036                         .channels_min = 1,
1037                         .channels_max = 2,
1038                         .rates = RT700_STEREO_RATES,
1039                         .formats = RT700_FORMATS,
1040                 },
1041                 .ops = &rt700_ops,
1042         },
1043         {
1044                 .name = "rt700-aif2",
1045                 .id = RT700_AIF2,
1046                 .playback = {
1047                         .stream_name = "DP3 Playback",
1048                         .channels_min = 1,
1049                         .channels_max = 2,
1050                         .rates = RT700_STEREO_RATES,
1051                         .formats = RT700_FORMATS,
1052                 },
1053                 .capture = {
1054                         .stream_name = "DP4 Capture",
1055                         .channels_min = 1,
1056                         .channels_max = 2,
1057                         .rates = RT700_STEREO_RATES,
1058                         .formats = RT700_FORMATS,
1059                 },
1060                 .ops = &rt700_ops,
1061         },
1062 };
1063
1064 /* Bus clock frequency */
1065 #define RT700_CLK_FREQ_9600000HZ 9600000
1066 #define RT700_CLK_FREQ_12000000HZ 12000000
1067 #define RT700_CLK_FREQ_6000000HZ 6000000
1068 #define RT700_CLK_FREQ_4800000HZ 4800000
1069 #define RT700_CLK_FREQ_2400000HZ 2400000
1070 #define RT700_CLK_FREQ_12288000HZ 12288000
1071
1072 int rt700_clock_config(struct device *dev)
1073 {
1074         struct rt700_priv *rt700 = dev_get_drvdata(dev);
1075         unsigned int clk_freq, value;
1076
1077         clk_freq = (rt700->params.curr_dr_freq >> 1);
1078
1079         switch (clk_freq) {
1080         case RT700_CLK_FREQ_12000000HZ:
1081                 value = 0x0;
1082                 break;
1083         case RT700_CLK_FREQ_6000000HZ:
1084                 value = 0x1;
1085                 break;
1086         case RT700_CLK_FREQ_9600000HZ:
1087                 value = 0x2;
1088                 break;
1089         case RT700_CLK_FREQ_4800000HZ:
1090                 value = 0x3;
1091                 break;
1092         case RT700_CLK_FREQ_2400000HZ:
1093                 value = 0x4;
1094                 break;
1095         case RT700_CLK_FREQ_12288000HZ:
1096                 value = 0x5;
1097                 break;
1098         default:
1099                 return -EINVAL;
1100         }
1101
1102         regmap_write(rt700->regmap, 0xe0, value);
1103         regmap_write(rt700->regmap, 0xf0, value);
1104
1105         dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
1106
1107         return 0;
1108 }
1109
1110 int rt700_init(struct device *dev, struct regmap *sdw_regmap,
1111                         struct regmap *regmap, struct sdw_slave *slave)
1112
1113 {
1114         struct rt700_priv *rt700;
1115         int ret;
1116
1117         rt700 = devm_kzalloc(dev, sizeof(*rt700), GFP_KERNEL);
1118         if (!rt700)
1119                 return -ENOMEM;
1120
1121         dev_set_drvdata(dev, rt700);
1122         rt700->slave = slave;
1123         rt700->sdw_regmap = sdw_regmap;
1124         rt700->regmap = regmap;
1125
1126         mutex_init(&rt700->disable_irq_lock);
1127
1128         INIT_DELAYED_WORK(&rt700->jack_detect_work,
1129                           rt700_jack_detect_handler);
1130         INIT_DELAYED_WORK(&rt700->jack_btn_check_work,
1131                           rt700_btn_check_handler);
1132
1133         /*
1134          * Mark hw_init to false
1135          * HW init will be performed when device reports present
1136          */
1137         rt700->hw_init = false;
1138         rt700->first_hw_init = false;
1139
1140         ret =  devm_snd_soc_register_component(dev,
1141                                 &soc_codec_dev_rt700,
1142                                 rt700_dai,
1143                                 ARRAY_SIZE(rt700_dai));
1144
1145         dev_dbg(&slave->dev, "%s\n", __func__);
1146
1147         return ret;
1148 }
1149
1150 int rt700_io_init(struct device *dev, struct sdw_slave *slave)
1151 {
1152         struct rt700_priv *rt700 = dev_get_drvdata(dev);
1153
1154         rt700->disable_irq = false;
1155
1156         if (rt700->hw_init)
1157                 return 0;
1158
1159         if (rt700->first_hw_init) {
1160                 regcache_cache_only(rt700->regmap, false);
1161                 regcache_cache_bypass(rt700->regmap, true);
1162         }
1163
1164         /*
1165          * PM runtime is only enabled when a Slave reports as Attached
1166          */
1167         if (!rt700->first_hw_init) {
1168                 /* set autosuspend parameters */
1169                 pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
1170                 pm_runtime_use_autosuspend(&slave->dev);
1171
1172                 /* update count of parent 'active' children */
1173                 pm_runtime_set_active(&slave->dev);
1174
1175                 /* make sure the device does not suspend immediately */
1176                 pm_runtime_mark_last_busy(&slave->dev);
1177
1178                 pm_runtime_enable(&slave->dev);
1179         }
1180
1181         pm_runtime_get_noresume(&slave->dev);
1182
1183         /* reset */
1184         regmap_write(rt700->regmap, 0xff01, 0x0000);
1185         regmap_write(rt700->regmap, 0x7520, 0x001a);
1186         regmap_write(rt700->regmap, 0x7420, 0xc003);
1187
1188         /* power on */
1189         regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
1190         /* Set Pin Widget */
1191         regmap_write(rt700->regmap, RT700_SET_PIN_HP, 0x40);
1192         regmap_write(rt700->regmap, RT700_SET_PIN_SPK, 0x40);
1193         regmap_write(rt700->regmap, RT700_SET_EAPD_SPK, RT700_EAPD_HIGH);
1194         regmap_write(rt700->regmap, RT700_SET_PIN_DMIC1, 0x20);
1195         regmap_write(rt700->regmap, RT700_SET_PIN_DMIC2, 0x20);
1196         regmap_write(rt700->regmap, RT700_SET_PIN_MIC2, 0x20);
1197
1198         /* Set Configuration Default */
1199         regmap_write(rt700->regmap, 0x4f12, 0x91);
1200         regmap_write(rt700->regmap, 0x4e12, 0xd6);
1201         regmap_write(rt700->regmap, 0x4d12, 0x11);
1202         regmap_write(rt700->regmap, 0x4c12, 0x20);
1203         regmap_write(rt700->regmap, 0x4f13, 0x91);
1204         regmap_write(rt700->regmap, 0x4e13, 0xd6);
1205         regmap_write(rt700->regmap, 0x4d13, 0x11);
1206         regmap_write(rt700->regmap, 0x4c13, 0x21);
1207
1208         regmap_write(rt700->regmap, 0x4f19, 0x02);
1209         regmap_write(rt700->regmap, 0x4e19, 0xa1);
1210         regmap_write(rt700->regmap, 0x4d19, 0x90);
1211         regmap_write(rt700->regmap, 0x4c19, 0x80);
1212
1213         /* Enable Line2 */
1214         regmap_write(rt700->regmap,  0x371b, 0x40);
1215         regmap_write(rt700->regmap,  0x731b, 0xb0);
1216         regmap_write(rt700->regmap,  0x839b, 0x00);
1217
1218         /* Set index */
1219         rt700_index_write(rt700->regmap, 0x4a, 0x201b);
1220         rt700_index_write(rt700->regmap, 0x45, 0x5089);
1221         rt700_index_write(rt700->regmap, 0x6b, 0x5064);
1222         rt700_index_write(rt700->regmap, 0x48, 0xd249);
1223
1224         /* Finish Initial Settings, set power to D3 */
1225         regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
1226
1227         /*
1228          * if set_jack callback occurred early than io_init,
1229          * we set up the jack detection function now
1230          */
1231         if (rt700->hs_jack)
1232                 rt700_jack_init(rt700);
1233
1234         if (rt700->first_hw_init) {
1235                 regcache_cache_bypass(rt700->regmap, false);
1236                 regcache_mark_dirty(rt700->regmap);
1237         } else
1238                 rt700->first_hw_init = true;
1239
1240         /* Mark Slave initialization complete */
1241         rt700->hw_init = true;
1242
1243         pm_runtime_mark_last_busy(&slave->dev);
1244         pm_runtime_put_autosuspend(&slave->dev);
1245
1246         dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1247
1248         return 0;
1249 }
1250
1251 MODULE_DESCRIPTION("ASoC RT700 driver SDW");
1252 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1253 MODULE_LICENSE("GPL v2");