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         int ret;
 822
 823         rt700->component = component;
 824
 825         ret = pm_runtime_resume(component->dev);
 826         if (ret < 0 && ret != -EACCES)
 827                 return ret;
 828
 829         return 0;
 830 }
 831
 832 static int rt700_set_bias_level(struct snd_soc_component *component,
 833                                 enum snd_soc_bias_level level)
 834 {
 835         struct snd_soc_dapm_context *dapm =
 836                 snd_soc_component_get_dapm(component);
 837         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 838
 839         switch (level) {
 840         case SND_SOC_BIAS_PREPARE:
 841                 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
 842                         regmap_write(rt700->regmap,
 843                                 RT700_SET_AUDIO_POWER_STATE,
 844                                 AC_PWRST_D0);
 845                 }
 846                 break;
 847
 848         case SND_SOC_BIAS_STANDBY:
 849                 regmap_write(rt700->regmap,
 850                         RT700_SET_AUDIO_POWER_STATE,
 851                         AC_PWRST_D3);
 852                 break;
 853
 854         default:
 855                 break;
 856         }
 857         dapm->bias_level = level;
 858         return 0;
 859 }
 860
 861 static const struct snd_soc_component_driver soc_codec_dev_rt700 = {
 862         .probe = rt700_probe,
 863         .set_bias_level = rt700_set_bias_level,
 864         .controls = rt700_snd_controls,
 865         .num_controls = ARRAY_SIZE(rt700_snd_controls),
 866         .dapm_widgets = rt700_dapm_widgets,
 867         .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets),
 868         .dapm_routes = rt700_audio_map,
 869         .num_dapm_routes = ARRAY_SIZE(rt700_audio_map),
 870         .set_jack = rt700_set_jack_detect,
 871         .endianness = 1,
 872 };
 873
 874 static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
 875                                 int direction)
 876 {
 877         struct sdw_stream_data *stream;
 878
 879         if (!sdw_stream)
 880                 return 0;
 881
 882         stream = kzalloc(sizeof(*stream), GFP_KERNEL);
 883         if (!stream)
 884                 return -ENOMEM;
 885
 886         stream->sdw_stream = sdw_stream;
 887
 888         /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
 889         if (direction == SNDRV_PCM_STREAM_PLAYBACK)
 890                 dai->playback_dma_data = stream;
 891         else
 892                 dai->capture_dma_data = stream;
 893
 894         return 0;
 895 }
 896
 897 static void rt700_shutdown(struct snd_pcm_substream *substream,
 898                                 struct snd_soc_dai *dai)
 899 {
 900         struct sdw_stream_data *stream;
 901
 902         stream = snd_soc_dai_get_dma_data(dai, substream);
 903         snd_soc_dai_set_dma_data(dai, substream, NULL);
 904         kfree(stream);
 905 }
 906
 907 static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
 908                                         struct snd_pcm_hw_params *params,
 909                                         struct snd_soc_dai *dai)
 910 {
 911         struct snd_soc_component *component = dai->component;
 912         struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
 913         struct sdw_stream_config stream_config;
 914         struct sdw_port_config port_config;
 915         enum sdw_data_direction direction;
 916         struct sdw_stream_data *stream;
 917         int retval, port, num_channels;
 918         unsigned int val = 0;
 919
 920         dev_dbg(dai->dev, "%s %s", __func__, dai->name);
 921         stream = snd_soc_dai_get_dma_data(dai, substream);
 922
 923         if (!stream)
 924                 return -EINVAL;
 925
 926         if (!rt700->slave)
 927                 return -EINVAL;
 928
 929         /* SoundWire specific configuration */
 930         /* This code assumes port 1 for playback and port 2 for capture */
 931         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 932                 direction = SDW_DATA_DIR_RX;
 933                 port = 1;
 934         } else {
 935                 direction = SDW_DATA_DIR_TX;
 936                 port = 2;
 937         }
 938
 939         switch (dai->id) {
 940         case RT700_AIF1:
 941                 break;
 942         case RT700_AIF2:
 943                 port += 2;
 944                 break;
 945         default:
 946                 dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
 947                 return -EINVAL;
 948         }
 949
 950         stream_config.frame_rate = params_rate(params);
 951         stream_config.ch_count = params_channels(params);
 952         stream_config.bps = snd_pcm_format_width(params_format(params));
 953         stream_config.direction = direction;
 954
 955         num_channels = params_channels(params);
 956         port_config.ch_mask = (1 << (num_channels)) - 1;
 957         port_config.num = port;
 958
 959         retval = sdw_stream_add_slave(rt700->slave, &stream_config,
 960                                         &port_config, 1, stream->sdw_stream);
 961         if (retval) {
 962                 dev_err(dai->dev, "Unable to configure port\n");
 963                 return retval;
 964         }
 965
 966         if (params_channels(params) <= 16) {
 967                 /* bit 3:0 Number of Channel */
 968                 val |= (params_channels(params) - 1);
 969         } else {
 970                 dev_err(component->dev, "Unsupported channels %d\n",
 971                         params_channels(params));
 972                 return -EINVAL;
 973         }
 974
 975         switch (params_width(params)) {
 976         /* bit 6:4 Bits per Sample */
 977         case 8:
 978                 break;
 979         case 16:
 980                 val |= (0x1 << 4);
 981                 break;
 982         case 20:
 983                 val |= (0x2 << 4);
 984                 break;
 985         case 24:
 986                 val |= (0x3 << 4);
 987                 break;
 988         case 32:
 989                 val |= (0x4 << 4);
 990                 break;
 991         default:
 992                 return -EINVAL;
 993         }
 994
 995         /* 48Khz */
 996         regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val);
 997         regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val);
 998
 999         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");