sound/soc/codecs/rt711.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // rt711.c -- rt711 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/sdw.h>
  23 #include <sound/soc.h>
  24 #include <sound/soc-dapm.h>
  25 #include <sound/initval.h>
  26 #include <sound/tlv.h>
  27 #include <sound/hda_verbs.h>
  28 #include <sound/jack.h>
  29
  30 #include "rt711.h"
  31
  32 static int rt711_index_write(struct regmap *regmap,
  33                 unsigned int nid, unsigned int reg, unsigned int value)
  34 {
  35         int ret;
  36         unsigned int addr = ((RT711_PRIV_INDEX_W_H | nid) << 8) | reg;
  37
  38         ret = regmap_write(regmap, addr, value);
  39         if (ret < 0)
  40                 pr_err("%s: Failed to set private value: %06x <= %04x ret=%d\n",
  41                        __func__, addr, value, ret);
  42
  43         return ret;
  44 }
  45
  46 static int rt711_index_read(struct regmap *regmap,
  47                 unsigned int nid, unsigned int reg, unsigned int *value)
  48 {
  49         int ret;
  50         unsigned int addr = ((RT711_PRIV_INDEX_W_H | nid) << 8) | reg;
  51
  52         *value = 0;
  53         ret = regmap_read(regmap, addr, value);
  54         if (ret < 0)
  55                 pr_err("%s: Failed to get private value: %06x => %04x ret=%d\n",
  56                        __func__, addr, *value, ret);
  57
  58         return ret;
  59 }
  60
  61 static int rt711_index_update_bits(struct regmap *regmap, unsigned int nid,
  62                         unsigned int reg, unsigned int mask, unsigned int val)
  63 {
  64         unsigned int tmp, orig;
  65         int ret;
  66
  67         ret = rt711_index_read(regmap, nid, reg, &orig);
  68         if (ret < 0)
  69                 return ret;
  70
  71         tmp = orig & ~mask;
  72         tmp |= val & mask;
  73
  74         return rt711_index_write(regmap, nid, reg, tmp);
  75 }
  76
  77 static void rt711_reset(struct regmap *regmap)
  78 {
  79         regmap_write(regmap, RT711_FUNC_RESET, 0);
  80         rt711_index_update_bits(regmap, RT711_VENDOR_REG,
  81                 RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET,
  82                 RT711_HIDDEN_REG_SW_RESET);
  83 }
  84
  85 static int rt711_calibration(struct rt711_priv *rt711)
  86 {
  87         unsigned int val, loop = 0;
  88         struct device *dev;
  89         struct regmap *regmap = rt711->regmap;
  90         int ret = 0;
  91
  92         mutex_lock(&rt711->calibrate_mutex);
  93         regmap_write(rt711->regmap,
  94                 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  95
  96         dev = regmap_get_device(regmap);
  97
  98         /* Calibration manual mode */
  99         rt711_index_update_bits(regmap, RT711_VENDOR_REG, RT711_FSM_CTL,
 100                 0xf, 0x0);
 101
 102         /* trigger */
 103         rt711_index_update_bits(regmap, RT711_VENDOR_CALI,
 104                 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER,
 105                 RT711_DAC_DC_CALI_TRIGGER);
 106
 107         /* wait for calibration process */
 108         rt711_index_read(regmap, RT711_VENDOR_CALI,
 109                 RT711_DAC_DC_CALI_CTL1, &val);
 110
 111         while (val & RT711_DAC_DC_CALI_TRIGGER) {
 112                 if (loop >= 500) {
 113                         pr_err("%s, calibration time-out!\n",
 114                                                         __func__);
 115                         ret = -ETIMEDOUT;
 116                         break;
 117                 }
 118                 loop++;
 119
 120                 usleep_range(10000, 11000);
 121                 rt711_index_read(regmap, RT711_VENDOR_CALI,
 122                         RT711_DAC_DC_CALI_CTL1, &val);
 123         }
 124
 125         /* depop mode */
 126         rt711_index_update_bits(regmap, RT711_VENDOR_REG,
 127                 RT711_FSM_CTL, 0xf, RT711_DEPOP_CTL);
 128
 129         regmap_write(rt711->regmap,
 130                 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
 131         mutex_unlock(&rt711->calibrate_mutex);
 132
 133         dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
 134         return ret;
 135 }
 136
 137 static unsigned int rt711_button_detect(struct rt711_priv *rt711)
 138 {
 139         unsigned int btn_type = 0, val80, val81;
 140         int ret;
 141
 142         ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
 143                                 RT711_IRQ_FLAG_TABLE1, &val80);
 144         if (ret < 0)
 145                 goto read_error;
 146         ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
 147                                         RT711_IRQ_FLAG_TABLE2, &val81);
 148         if (ret < 0)
 149                 goto read_error;
 150
 151         val80 &= 0x0381;
 152         val81 &= 0xff00;
 153
 154         switch (val80) {
 155         case 0x0200:
 156         case 0x0100:
 157         case 0x0080:
 158                 btn_type |= SND_JACK_BTN_0;
 159                 break;
 160         case 0x0001:
 161                 btn_type |= SND_JACK_BTN_3;
 162                 break;
 163         }
 164         switch (val81) {
 165         case 0x8000:
 166         case 0x4000:
 167         case 0x2000:
 168                 btn_type |= SND_JACK_BTN_1;
 169                 break;
 170         case 0x1000:
 171         case 0x0800:
 172         case 0x0400:
 173                 btn_type |= SND_JACK_BTN_2;
 174                 break;
 175         case 0x0200:
 176         case 0x0100:
 177                 btn_type |= SND_JACK_BTN_3;
 178                 break;
 179         }
 180 read_error:
 181         return btn_type;
 182 }
 183
 184 static int rt711_headset_detect(struct rt711_priv *rt711)
 185 {
 186         unsigned int buf, loop = 0;
 187         int ret;
 188         unsigned int jack_status = 0, reg;
 189
 190         ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
 191                                 RT711_COMBO_JACK_AUTO_CTL2, &buf);
 192         if (ret < 0)
 193                 goto io_error;
 194
 195         while (loop < 500 &&
 196                 (buf & RT711_COMBOJACK_AUTO_DET_STATUS) == 0) {
 197                 loop++;
 198
 199                 usleep_range(9000, 10000);
 200                 ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
 201                                         RT711_COMBO_JACK_AUTO_CTL2, &buf);
 202                 if (ret < 0)
 203                         goto io_error;
 204
 205                 reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
 206                 ret = regmap_read(rt711->regmap, reg, &jack_status);
 207                 if (ret < 0)
 208                         goto io_error;
 209                 if ((jack_status & (1 << 31)) == 0)
 210                         goto remove_error;
 211         }
 212
 213         if (loop >= 500)
 214                 goto to_error;
 215
 216         if (buf & RT711_COMBOJACK_AUTO_DET_TRS)
 217                 rt711->jack_type = SND_JACK_HEADPHONE;
 218         else if ((buf & RT711_COMBOJACK_AUTO_DET_CTIA) ||
 219                 (buf & RT711_COMBOJACK_AUTO_DET_OMTP))
 220                 rt711->jack_type = SND_JACK_HEADSET;
 221
 222         return 0;
 223
 224 to_error:
 225         ret = -ETIMEDOUT;
 226         pr_err_ratelimited("Time-out error in %s\n", __func__);
 227         return ret;
 228 io_error:
 229         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 230         return ret;
 231 remove_error:
 232         pr_err_ratelimited("Jack removal in %s\n", __func__);
 233         return -ENODEV;
 234 }
 235
 236 static void rt711_jack_detect_handler(struct work_struct *work)
 237 {
 238         struct rt711_priv *rt711 =
 239                 container_of(work, struct rt711_priv, jack_detect_work.work);
 240         int btn_type = 0, ret;
 241         unsigned int jack_status = 0, reg;
 242
 243         if (!rt711->hs_jack)
 244                 return;
 245
 246         if (!snd_soc_card_is_instantiated(rt711->component->card))
 247                 return;
 248
 249         if (pm_runtime_status_suspended(rt711->slave->dev.parent)) {
 250                 dev_dbg(&rt711->slave->dev,
 251                         "%s: parent device is pm_runtime_status_suspended, skipping jack detection\n",
 252                         __func__);
 253                 return;
 254         }
 255
 256         reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
 257         ret = regmap_read(rt711->regmap, reg, &jack_status);
 258         if (ret < 0)
 259                 goto io_error;
 260
 261         /* pin attached */
 262         if (jack_status & (1 << 31)) {
 263                 /* jack in */
 264                 if (rt711->jack_type == 0) {
 265                         ret = rt711_headset_detect(rt711);
 266                         if (ret < 0)
 267                                 return;
 268                         if (rt711->jack_type == SND_JACK_HEADSET)
 269                                 btn_type = rt711_button_detect(rt711);
 270                 } else if (rt711->jack_type == SND_JACK_HEADSET) {
 271                         /* jack is already in, report button event */
 272                         btn_type = rt711_button_detect(rt711);
 273                 }
 274         } else {
 275                 /* jack out */
 276                 rt711->jack_type = 0;
 277         }
 278
 279         dev_dbg(&rt711->slave->dev,
 280                 "in %s, jack_type=0x%x\n", __func__, rt711->jack_type);
 281         dev_dbg(&rt711->slave->dev,
 282                 "in %s, btn_type=0x%x\n", __func__, btn_type);
 283
 284         snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
 285                         SND_JACK_HEADSET |
 286                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 287                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 288
 289         if (btn_type) {
 290                 /* button released */
 291                 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
 292                         SND_JACK_HEADSET |
 293                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 294                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 295
 296                 mod_delayed_work(system_power_efficient_wq,
 297                         &rt711->jack_btn_check_work, msecs_to_jiffies(200));
 298         }
 299
 300         return;
 301
 302 io_error:
 303         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 304 }
 305
 306 static void rt711_btn_check_handler(struct work_struct *work)
 307 {
 308         struct rt711_priv *rt711 = container_of(work, struct rt711_priv,
 309                 jack_btn_check_work.work);
 310         int btn_type = 0, ret;
 311         unsigned int jack_status = 0, reg;
 312
 313         reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
 314         ret = regmap_read(rt711->regmap, reg, &jack_status);
 315         if (ret < 0)
 316                 goto io_error;
 317
 318         /* pin attached */
 319         if (jack_status & (1 << 31)) {
 320                 if (rt711->jack_type == SND_JACK_HEADSET) {
 321                         /* jack is already in, report button event */
 322                         btn_type = rt711_button_detect(rt711);
 323                 }
 324         } else {
 325                 rt711->jack_type = 0;
 326         }
 327
 328         /* cbj comparator */
 329         ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
 330                 RT711_COMBO_JACK_AUTO_CTL2, &reg);
 331         if (ret < 0)
 332                 goto io_error;
 333
 334         if ((reg & 0xf0) == 0xf0)
 335                 btn_type = 0;
 336
 337         dev_dbg(&rt711->slave->dev,
 338                 "%s, btn_type=0x%x\n",  __func__, btn_type);
 339         snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
 340                         SND_JACK_HEADSET |
 341                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 342                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 343
 344         if (btn_type) {
 345                 /* button released */
 346                 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
 347                         SND_JACK_HEADSET |
 348                         SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 349                         SND_JACK_BTN_2 | SND_JACK_BTN_3);
 350
 351                 mod_delayed_work(system_power_efficient_wq,
 352                         &rt711->jack_btn_check_work, msecs_to_jiffies(200));
 353         }
 354
 355         return;
 356
 357 io_error:
 358         pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 359 }
 360
 361 static void rt711_jack_init(struct rt711_priv *rt711)
 362 {
 363         struct snd_soc_dapm_context *dapm =
 364                 snd_soc_component_get_dapm(rt711->component);
 365
 366         mutex_lock(&rt711->calibrate_mutex);
 367         /* power on */
 368         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 369                 regmap_write(rt711->regmap,
 370                         RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
 371
 372         if (rt711->hs_jack) {
 373                 /* unsolicited response & IRQ control */
 374                 regmap_write(rt711->regmap,
 375                         RT711_SET_MIC2_UNSOLICITED_ENABLE, 0x82);
 376                 regmap_write(rt711->regmap,
 377                         RT711_SET_HP_UNSOLICITED_ENABLE, 0x81);
 378                 regmap_write(rt711->regmap,
 379                         RT711_SET_INLINE_UNSOLICITED_ENABLE, 0x83);
 380                 rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
 381                         0x10, 0x2420);
 382                 rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
 383                         0x19, 0x2e11);
 384
 385                 switch (rt711->jd_src) {
 386                 case RT711_JD1:
 387                         /* default settings was already for JD1 */
 388                         break;
 389                 case RT711_JD2:
 390                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 391                                 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP |
 392                                 RT711_HP_JD_SEL_JD2,
 393                                 RT711_JD2_2PORT_200K_DECODE_HP |
 394                                 RT711_HP_JD_SEL_JD2);
 395                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 396                                 RT711_CC_DET1,
 397                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12,
 398                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12);
 399                         break;
 400                 case RT711_JD2_100K:
 401                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 402                                 RT711_JD_CTL2, RT711_JD2_2PORT_100K_DECODE | RT711_JD2_1PORT_TYPE_DECODE |
 403                                 RT711_HP_JD_SEL_JD2 | RT711_JD1_2PORT_TYPE_100K_DECODE,
 404                                 RT711_JD2_2PORT_100K_DECODE_HP | RT711_JD2_1PORT_JD_HP |
 405                                 RT711_HP_JD_SEL_JD2 | RT711_JD1_2PORT_JD_RESERVED);
 406                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 407                                 RT711_CC_DET1,
 408                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12,
 409                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12);
 410                         break;
 411                 case RT711_JD2_1P8V_1PORT:
 412                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 413                                 RT711_JD_CTL1, RT711_JD2_DIGITAL_JD_MODE_SEL,
 414                                 RT711_JD2_1_JD_MODE);
 415                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 416                                 RT711_JD_CTL2, RT711_JD2_1PORT_TYPE_DECODE |
 417                                 RT711_HP_JD_SEL_JD2,
 418                                 RT711_JD2_1PORT_JD_HP |
 419                                 RT711_HP_JD_SEL_JD2);
 420                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 421                                 RT711_JD_CTL4, RT711_JD2_PAD_PULL_UP_MASK |
 422                                 RT711_JD2_MODE_SEL_MASK,
 423                                 RT711_JD2_PAD_PULL_UP |
 424                                 RT711_JD2_MODE2_1P8V_1PORT);
 425                         rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
 426                                 RT711_CC_DET1,
 427                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12,
 428                                 RT711_HP_JD_FINAL_RESULT_CTL_JD12);
 429                         break;
 430                 default:
 431                         dev_warn(rt711->component->dev, "%s: Wrong JD source\n", __func__);
 432                         break;
 433                 }
 434
 435                 dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__);
 436
 437                 mod_delayed_work(system_power_efficient_wq,
 438                         &rt711->jack_detect_work, msecs_to_jiffies(250));
 439         } else {
 440                 regmap_write(rt711->regmap,
 441                         RT711_SET_MIC2_UNSOLICITED_ENABLE, 0x00);
 442                 regmap_write(rt711->regmap,
 443                         RT711_SET_HP_UNSOLICITED_ENABLE, 0x00);
 444                 regmap_write(rt711->regmap,
 445                         RT711_SET_INLINE_UNSOLICITED_ENABLE, 0x00);
 446
 447                 dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__);
 448         }
 449
 450         /* power off */
 451         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 452                 regmap_write(rt711->regmap,
 453                         RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
 454         mutex_unlock(&rt711->calibrate_mutex);
 455 }
 456
 457 static int rt711_set_jack_detect(struct snd_soc_component *component,
 458         struct snd_soc_jack *hs_jack, void *data)
 459 {
 460         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 461         int ret;
 462
 463         rt711->hs_jack = hs_jack;
 464
 465         /* we can only resume if the device was initialized at least once */
 466         if (!rt711->first_hw_init)
 467                 return 0;
 468
 469         ret = pm_runtime_resume_and_get(component->dev);
 470         if (ret < 0) {
 471                 if (ret != -EACCES) {
 472                         dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
 473                         return ret;
 474                 }
 475
 476                 /* pm_runtime not enabled yet */
 477                 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
 478                 return 0;
 479         }
 480
 481         rt711_jack_init(rt711);
 482
 483         pm_runtime_mark_last_busy(component->dev);
 484         pm_runtime_put_autosuspend(component->dev);
 485
 486         return 0;
 487 }
 488
 489 static void rt711_get_gain(struct rt711_priv *rt711, unsigned int addr_h,
 490                                 unsigned int addr_l, unsigned int val_h,
 491                                 unsigned int *r_val, unsigned int *l_val)
 492 {
 493         /* R Channel */
 494         *r_val = (val_h << 8);
 495         regmap_read(rt711->regmap, addr_l, r_val);
 496
 497         /* L Channel */
 498         val_h |= 0x20;
 499         *l_val = (val_h << 8);
 500         regmap_read(rt711->regmap, addr_h, l_val);
 501 }
 502
 503 /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
 504 static int rt711_set_amp_gain_put(struct snd_kcontrol *kcontrol,
 505                 struct snd_ctl_elem_value *ucontrol)
 506 {
 507         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 508         struct snd_soc_dapm_context *dapm =
 509                 snd_soc_component_get_dapm(component);
 510         struct soc_mixer_control *mc =
 511                 (struct soc_mixer_control *)kcontrol->private_value;
 512         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 513         unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
 514         unsigned int read_ll, read_rl;
 515         int i;
 516
 517         mutex_lock(&rt711->calibrate_mutex);
 518
 519         /* Can't use update bit function, so read the original value first */
 520         addr_h = mc->reg;
 521         addr_l = mc->rreg;
 522         if (mc->shift == RT711_DIR_OUT_SFT) /* output */
 523                 val_h = 0x80;
 524         else /* input */
 525                 val_h = 0x0;
 526
 527         rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll);
 528
 529         /* L Channel */
 530         if (mc->invert) {
 531                 /* for mute/unmute */
 532                 val_ll = (mc->max - ucontrol->value.integer.value[0])
 533                                         << RT711_MUTE_SFT;
 534                 /* keep gain */
 535                 read_ll = read_ll & 0x7f;
 536                 val_ll |= read_ll;
 537         } else {
 538                 /* for gain */
 539                 val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
 540                 if (val_ll > mc->max)
 541                         val_ll = mc->max;
 542                 /* keep mute status */
 543                 read_ll = read_ll & (1 << RT711_MUTE_SFT);
 544                 val_ll |= read_ll;
 545         }
 546
 547         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 548                 regmap_write(rt711->regmap,
 549                                 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
 550
 551         /* R Channel */
 552         if (mc->invert) {
 553                 /* for mute/unmute */
 554                 val_lr = (mc->max - ucontrol->value.integer.value[1])
 555                                         << RT711_MUTE_SFT;
 556                 /* keep gain */
 557                 read_rl = read_rl & 0x7f;
 558                 val_lr |= read_rl;
 559         } else {
 560                 /* for gain */
 561                 val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
 562                 if (val_lr > mc->max)
 563                         val_lr = mc->max;
 564                 /* keep mute status */
 565                 read_rl = read_rl & (1 << RT711_MUTE_SFT);
 566                 val_lr |= read_rl;
 567         }
 568
 569         for (i = 0; i < 3; i++) { /* retry 3 times at most */
 570
 571                 if (val_ll == val_lr) {
 572                         /* Set both L/R channels at the same time */
 573                         val_h = (1 << mc->shift) | (3 << 4);
 574                         regmap_write(rt711->regmap,
 575                                 addr_h, (val_h << 8 | val_ll));
 576                         regmap_write(rt711->regmap,
 577                                 addr_l, (val_h << 8 | val_ll));
 578                 } else {
 579                         /* Lch*/
 580                         val_h = (1 << mc->shift) | (1 << 5);
 581                         regmap_write(rt711->regmap,
 582                                 addr_h, (val_h << 8 | val_ll));
 583
 584                         /* Rch */
 585                         val_h = (1 << mc->shift) | (1 << 4);
 586                         regmap_write(rt711->regmap,
 587                                 addr_l, (val_h << 8 | val_lr));
 588                 }
 589                 /* check result */
 590                 if (mc->shift == RT711_DIR_OUT_SFT) /* output */
 591                         val_h = 0x80;
 592                 else /* input */
 593                         val_h = 0x0;
 594
 595                 rt711_get_gain(rt711, addr_h, addr_l, val_h,
 596                                         &read_rl, &read_ll);
 597                 if (read_rl == val_lr && read_ll == val_ll)
 598                         break;
 599         }
 600
 601         if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
 602                 regmap_write(rt711->regmap,
 603                                 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
 604
 605         mutex_unlock(&rt711->calibrate_mutex);
 606         return 0;
 607 }
 608
 609 static int rt711_set_amp_gain_get(struct snd_kcontrol *kcontrol,
 610                 struct snd_ctl_elem_value *ucontrol)
 611 {
 612         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 613         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 614         struct soc_mixer_control *mc =
 615                 (struct soc_mixer_control *)kcontrol->private_value;
 616         unsigned int addr_h, addr_l, val_h;
 617         unsigned int read_ll, read_rl;
 618
 619         /* switch to get command */
 620         addr_h = mc->reg;
 621         addr_l = mc->rreg;
 622         if (mc->shift == RT711_DIR_OUT_SFT) /* output */
 623                 val_h = 0x80;
 624         else /* input */
 625                 val_h = 0x0;
 626
 627         rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll);
 628
 629         if (mc->invert) {
 630                 /* mute/unmute for switch controls */
 631                 read_ll = !((read_ll & 0x80) >> RT711_MUTE_SFT);
 632                 read_rl = !((read_rl & 0x80) >> RT711_MUTE_SFT);
 633         } else {
 634                 /* for gain volume controls */
 635                 read_ll = read_ll & 0x7f;
 636                 read_rl = read_rl & 0x7f;
 637         }
 638         ucontrol->value.integer.value[0] = read_ll;
 639         ucontrol->value.integer.value[1] = read_rl;
 640
 641         return 0;
 642 }
 643
 644 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
 645 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
 646 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
 647
 648 static const struct snd_kcontrol_new rt711_snd_controls[] = {
 649         SOC_DOUBLE_R_EXT_TLV("DAC Surr Playback Volume",
 650                 RT711_SET_GAIN_DAC2_H, RT711_SET_GAIN_DAC2_L,
 651                 RT711_DIR_OUT_SFT, 0x57, 0,
 652                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, out_vol_tlv),
 653         SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
 654                 RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L,
 655                 RT711_DIR_IN_SFT, 1, 1,
 656                 rt711_set_amp_gain_get, rt711_set_amp_gain_put),
 657         SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
 658                 RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L,
 659                 RT711_DIR_IN_SFT, 1, 1,
 660                 rt711_set_amp_gain_get, rt711_set_amp_gain_put),
 661         SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
 662                 RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L,
 663                 RT711_DIR_IN_SFT, 0x3f, 0,
 664                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv),
 665         SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
 666                 RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L,
 667                 RT711_DIR_IN_SFT, 0x3f, 0,
 668                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv),
 669         SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
 670                 RT711_SET_GAIN_AMIC_H, RT711_SET_GAIN_AMIC_L,
 671                 RT711_DIR_IN_SFT, 3, 0,
 672                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
 673         SOC_DOUBLE_R_EXT_TLV("DMIC1 Volume",
 674                 RT711_SET_GAIN_DMIC1_H, RT711_SET_GAIN_DMIC1_L,
 675                 RT711_DIR_IN_SFT, 3, 0,
 676                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
 677         SOC_DOUBLE_R_EXT_TLV("DMIC2 Volume",
 678                 RT711_SET_GAIN_DMIC2_H, RT711_SET_GAIN_DMIC2_L,
 679                 RT711_DIR_IN_SFT, 3, 0,
 680                 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
 681 };
 682
 683 static int rt711_mux_get(struct snd_kcontrol *kcontrol,
 684                         struct snd_ctl_elem_value *ucontrol)
 685 {
 686         struct snd_soc_component *component =
 687                 snd_soc_dapm_kcontrol_component(kcontrol);
 688         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 689         unsigned int reg, val = 0, nid;
 690         int ret;
 691
 692         if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 693                 nid = RT711_MIXER_IN1;
 694         else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 695                 nid = RT711_MIXER_IN2;
 696         else
 697                 return -EINVAL;
 698
 699         /* vid = 0xf01 */
 700         reg = RT711_VERB_SET_CONNECT_SEL | nid;
 701         ret = regmap_read(rt711->regmap, reg, &val);
 702         if (ret < 0) {
 703                 dev_err(component->dev, "%s: sdw read failed: %d\n",
 704                         __func__, ret);
 705                 return ret;
 706         }
 707
 708         ucontrol->value.enumerated.item[0] = val;
 709
 710         return 0;
 711 }
 712
 713 static int rt711_mux_put(struct snd_kcontrol *kcontrol,
 714                         struct snd_ctl_elem_value *ucontrol)
 715 {
 716         struct snd_soc_component *component =
 717                 snd_soc_dapm_kcontrol_component(kcontrol);
 718         struct snd_soc_dapm_context *dapm =
 719                 snd_soc_dapm_kcontrol_dapm(kcontrol);
 720         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 721         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 722         unsigned int *item = ucontrol->value.enumerated.item;
 723         unsigned int val, val2 = 0, change, reg, nid;
 724         int ret;
 725
 726         if (item[0] >= e->items)
 727                 return -EINVAL;
 728
 729         if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 730                 nid = RT711_MIXER_IN1;
 731         else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 732                 nid = RT711_MIXER_IN2;
 733         else
 734                 return -EINVAL;
 735
 736         /* Verb ID = 0x701h */
 737         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
 738
 739         reg = RT711_VERB_SET_CONNECT_SEL | nid;
 740         ret = regmap_read(rt711->regmap, reg, &val2);
 741         if (ret < 0) {
 742                 dev_err(component->dev, "%s: sdw read failed: %d\n",
 743                         __func__, ret);
 744                 return ret;
 745         }
 746
 747         if (val == val2)
 748                 change = 0;
 749         else
 750                 change = 1;
 751
 752         if (change) {
 753                 reg = RT711_VERB_SET_CONNECT_SEL | nid;
 754                 regmap_write(rt711->regmap, reg, val);
 755         }
 756
 757         snd_soc_dapm_mux_update_power(dapm, kcontrol,
 758                                                 item[0], e, NULL);
 759
 760         return change;
 761 }
 762
 763 static const char * const adc_mux_text[] = {
 764         "MIC2",
 765         "LINE1",
 766         "LINE2",
 767         "DMIC",
 768 };
 769
 770 static SOC_ENUM_SINGLE_DECL(
 771         rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
 772
 773 static SOC_ENUM_SINGLE_DECL(
 774         rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
 775
 776 static const struct snd_kcontrol_new rt711_adc22_mux =
 777         SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum,
 778                         rt711_mux_get, rt711_mux_put);
 779
 780 static const struct snd_kcontrol_new rt711_adc23_mux =
 781         SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum,
 782                         rt711_mux_get, rt711_mux_put);
 783
 784 static int rt711_dac_surround_event(struct snd_soc_dapm_widget *w,
 785         struct snd_kcontrol *kcontrol, int event)
 786 {
 787         struct snd_soc_component *component =
 788                 snd_soc_dapm_to_component(w->dapm);
 789         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 790         unsigned int val_h = (1 << RT711_DIR_OUT_SFT) | (0x3 << 4);
 791         unsigned int val_l;
 792
 793         switch (event) {
 794         case SND_SOC_DAPM_POST_PMU:
 795                 regmap_write(rt711->regmap,
 796                         RT711_SET_STREAMID_DAC2, 0x10);
 797
 798                 val_l = 0x00;
 799                 regmap_write(rt711->regmap,
 800                         RT711_SET_GAIN_HP_H, (val_h << 8 | val_l));
 801                 break;
 802         case SND_SOC_DAPM_PRE_PMD:
 803                 val_l = (1 << RT711_MUTE_SFT);
 804                 regmap_write(rt711->regmap,
 805                         RT711_SET_GAIN_HP_H, (val_h << 8 | val_l));
 806                 usleep_range(50000, 55000);
 807
 808                 regmap_write(rt711->regmap,
 809                         RT711_SET_STREAMID_DAC2, 0x00);
 810                 break;
 811         }
 812         return 0;
 813 }
 814
 815 static int rt711_adc_09_event(struct snd_soc_dapm_widget *w,
 816         struct snd_kcontrol *kcontrol, int event)
 817 {
 818         struct snd_soc_component *component =
 819                 snd_soc_dapm_to_component(w->dapm);
 820         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 821
 822         switch (event) {
 823         case SND_SOC_DAPM_POST_PMU:
 824                 regmap_write(rt711->regmap,
 825                         RT711_SET_STREAMID_ADC1, 0x10);
 826                 break;
 827         case SND_SOC_DAPM_PRE_PMD:
 828                 regmap_write(rt711->regmap,
 829                         RT711_SET_STREAMID_ADC1, 0x00);
 830                 break;
 831         }
 832         return 0;
 833 }
 834
 835 static int rt711_adc_08_event(struct snd_soc_dapm_widget *w,
 836         struct snd_kcontrol *kcontrol, int event)
 837 {
 838         struct snd_soc_component *component =
 839                 snd_soc_dapm_to_component(w->dapm);
 840         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 841
 842         switch (event) {
 843         case SND_SOC_DAPM_POST_PMU:
 844                 regmap_write(rt711->regmap,
 845                         RT711_SET_STREAMID_ADC2, 0x10);
 846                 break;
 847         case SND_SOC_DAPM_PRE_PMD:
 848                 regmap_write(rt711->regmap,
 849                         RT711_SET_STREAMID_ADC2, 0x00);
 850                 break;
 851         }
 852         return 0;
 853 }
 854
 855 static const struct snd_soc_dapm_widget rt711_dapm_widgets[] = {
 856         SND_SOC_DAPM_OUTPUT("HP"),
 857         SND_SOC_DAPM_INPUT("MIC2"),
 858         SND_SOC_DAPM_INPUT("DMIC1"),
 859         SND_SOC_DAPM_INPUT("DMIC2"),
 860         SND_SOC_DAPM_INPUT("LINE1"),
 861         SND_SOC_DAPM_INPUT("LINE2"),
 862
 863         SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
 864                 rt711_dac_surround_event,
 865                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 866         SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
 867                 rt711_adc_09_event,
 868                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 869         SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
 870                 rt711_adc_08_event,
 871                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 872         SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
 873                 &rt711_adc22_mux),
 874         SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
 875                 &rt711_adc23_mux),
 876
 877         SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
 878         SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
 879         SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
 880 };
 881
 882 static const struct snd_soc_dapm_route rt711_audio_map[] = {
 883         {"DAC Surround", NULL, "DP3RX"},
 884         {"DP2TX", NULL, "ADC 09"},
 885         {"DP4TX", NULL, "ADC 08"},
 886
 887         {"ADC 09", NULL, "ADC 22 Mux"},
 888         {"ADC 08", NULL, "ADC 23 Mux"},
 889         {"ADC 22 Mux", "DMIC", "DMIC1"},
 890         {"ADC 22 Mux", "LINE1", "LINE1"},
 891         {"ADC 22 Mux", "LINE2", "LINE2"},
 892         {"ADC 22 Mux", "MIC2", "MIC2"},
 893         {"ADC 23 Mux", "DMIC", "DMIC2"},
 894         {"ADC 23 Mux", "LINE1", "LINE1"},
 895         {"ADC 23 Mux", "LINE2", "LINE2"},
 896         {"ADC 23 Mux", "MIC2", "MIC2"},
 897
 898         {"HP", NULL, "DAC Surround"},
 899 };
 900
 901 static int rt711_set_bias_level(struct snd_soc_component *component,
 902                                 enum snd_soc_bias_level level)
 903 {
 904         struct snd_soc_dapm_context *dapm =
 905                 snd_soc_component_get_dapm(component);
 906         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 907
 908         switch (level) {
 909         case SND_SOC_BIAS_PREPARE:
 910                 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
 911                         regmap_write(rt711->regmap,
 912                                 RT711_SET_AUDIO_POWER_STATE,
 913                                 AC_PWRST_D0);
 914                 }
 915                 break;
 916
 917         case SND_SOC_BIAS_STANDBY:
 918                 mutex_lock(&rt711->calibrate_mutex);
 919                 regmap_write(rt711->regmap,
 920                         RT711_SET_AUDIO_POWER_STATE,
 921                         AC_PWRST_D3);
 922                 mutex_unlock(&rt711->calibrate_mutex);
 923                 break;
 924
 925         default:
 926                 break;
 927         }
 928
 929         return 0;
 930 }
 931
 932 static int rt711_parse_dt(struct rt711_priv *rt711, struct device *dev)
 933 {
 934         device_property_read_u32(dev, "realtek,jd-src",
 935                 &rt711->jd_src);
 936
 937         return 0;
 938 }
 939
 940 static int rt711_probe(struct snd_soc_component *component)
 941 {
 942         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 943         int ret;
 944
 945         rt711_parse_dt(rt711, &rt711->slave->dev);
 946         rt711->component = component;
 947
 948         if (!rt711->first_hw_init)
 949                 return 0;
 950
 951         ret = pm_runtime_resume(component->dev);
 952         if (ret < 0 && ret != -EACCES)
 953                 return ret;
 954
 955         return 0;
 956 }
 957
 958 static const struct snd_soc_component_driver soc_codec_dev_rt711 = {
 959         .probe = rt711_probe,
 960         .set_bias_level = rt711_set_bias_level,
 961         .controls = rt711_snd_controls,
 962         .num_controls = ARRAY_SIZE(rt711_snd_controls),
 963         .dapm_widgets = rt711_dapm_widgets,
 964         .num_dapm_widgets = ARRAY_SIZE(rt711_dapm_widgets),
 965         .dapm_routes = rt711_audio_map,
 966         .num_dapm_routes = ARRAY_SIZE(rt711_audio_map),
 967         .set_jack = rt711_set_jack_detect,
 968         .endianness = 1,
 969 };
 970
 971 static int rt711_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
 972                                 int direction)
 973 {
 974         snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
 975
 976         return 0;
 977 }
 978
 979 static void rt711_shutdown(struct snd_pcm_substream *substream,
 980                                 struct snd_soc_dai *dai)
 981 {
 982         snd_soc_dai_set_dma_data(dai, substream, NULL);
 983 }
 984
 985 static int rt711_pcm_hw_params(struct snd_pcm_substream *substream,
 986                                 struct snd_pcm_hw_params *params,
 987                                 struct snd_soc_dai *dai)
 988 {
 989         struct snd_soc_component *component = dai->component;
 990         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
 991         struct sdw_stream_config stream_config = {0};
 992         struct sdw_port_config port_config = {0};
 993         struct sdw_stream_runtime *sdw_stream;
 994         int retval;
 995         unsigned int val = 0;
 996
 997         dev_dbg(dai->dev, "%s %s", __func__, dai->name);
 998         sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
 999
1000         if (!sdw_stream)
1001                 return -EINVAL;
1002
1003         if (!rt711->slave)
1004                 return -EINVAL;
1005
1006         /* SoundWire specific configuration */
1007         snd_sdw_params_to_config(substream, params, &stream_config, &port_config);
1008
1009         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1010                 port_config.num = 3;
1011         } else {
1012                 if (dai->id == RT711_AIF1)
1013                         port_config.num = 4;
1014                 else if (dai->id == RT711_AIF2)
1015                         port_config.num = 2;
1016                 else
1017                         return -EINVAL;
1018         }
1019
1020         retval = sdw_stream_add_slave(rt711->slave, &stream_config,
1021                                         &port_config, 1, sdw_stream);
1022         if (retval) {
1023                 dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
1024                 return retval;
1025         }
1026
1027         if (params_channels(params) <= 16) {
1028                 /* bit 3:0 Number of Channel */
1029                 val |= (params_channels(params) - 1);
1030         } else {
1031                 dev_err(component->dev, "%s: Unsupported channels %d\n",
1032                         __func__, params_channels(params));
1033                 return -EINVAL;
1034         }
1035
1036         switch (params_width(params)) {
1037         /* bit 6:4 Bits per Sample */
1038         case 8:
1039                 break;
1040         case 16:
1041                 val |= (0x1 << 4);
1042                 break;
1043         case 20:
1044                 val |= (0x2 << 4);
1045                 break;
1046         case 24:
1047                 val |= (0x3 << 4);
1048                 break;
1049         case 32:
1050                 val |= (0x4 << 4);
1051                 break;
1052         default:
1053                 return -EINVAL;
1054         }
1055
1056         /* 48Khz */
1057         regmap_write(rt711->regmap, RT711_DAC_FORMAT_H, val);
1058         regmap_write(rt711->regmap, RT711_ADC1_FORMAT_H, val);
1059         regmap_write(rt711->regmap, RT711_ADC2_FORMAT_H, val);
1060
1061         return retval;
1062 }
1063
1064 static int rt711_pcm_hw_free(struct snd_pcm_substream *substream,
1065                                 struct snd_soc_dai *dai)
1066 {
1067         struct snd_soc_component *component = dai->component;
1068         struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
1069         struct sdw_stream_runtime *sdw_stream =
1070                 snd_soc_dai_get_dma_data(dai, substream);
1071
1072         if (!rt711->slave)
1073                 return -EINVAL;
1074
1075         sdw_stream_remove_slave(rt711->slave, sdw_stream);
1076         return 0;
1077 }
1078
1079 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
1080 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1081                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
1082
1083 static const struct snd_soc_dai_ops rt711_ops = {
1084         .hw_params      = rt711_pcm_hw_params,
1085         .hw_free        = rt711_pcm_hw_free,
1086         .set_stream     = rt711_set_sdw_stream,
1087         .shutdown       = rt711_shutdown,
1088 };
1089
1090 static struct snd_soc_dai_driver rt711_dai[] = {
1091         {
1092                 .name = "rt711-aif1",
1093                 .id = RT711_AIF1,
1094                 .playback = {
1095                         .stream_name = "DP3 Playback",
1096                         .channels_min = 1,
1097                         .channels_max = 2,
1098                         .rates = RT711_STEREO_RATES,
1099                         .formats = RT711_FORMATS,
1100                 },
1101                 .capture = {
1102                         .stream_name = "DP4 Capture",
1103                         .channels_min = 1,
1104                         .channels_max = 2,
1105                         .rates = RT711_STEREO_RATES,
1106                         .formats = RT711_FORMATS,
1107                 },
1108                 .ops = &rt711_ops,
1109         },
1110         {
1111                 .name = "rt711-aif2",
1112                 .id = RT711_AIF2,
1113                 .capture = {
1114                         .stream_name = "DP2 Capture",
1115                         .channels_min = 1,
1116                         .channels_max = 2,
1117                         .rates = RT711_STEREO_RATES,
1118                         .formats = RT711_FORMATS,
1119                 },
1120                 .ops = &rt711_ops,
1121         }
1122 };
1123
1124 /* Bus clock frequency */
1125 #define RT711_CLK_FREQ_9600000HZ 9600000
1126 #define RT711_CLK_FREQ_12000000HZ 12000000
1127 #define RT711_CLK_FREQ_6000000HZ 6000000
1128 #define RT711_CLK_FREQ_4800000HZ 4800000
1129 #define RT711_CLK_FREQ_2400000HZ 2400000
1130 #define RT711_CLK_FREQ_12288000HZ 12288000
1131
1132 int rt711_clock_config(struct device *dev)
1133 {
1134         struct rt711_priv *rt711 = dev_get_drvdata(dev);
1135         unsigned int clk_freq, value;
1136
1137         clk_freq = (rt711->params.curr_dr_freq >> 1);
1138
1139         switch (clk_freq) {
1140         case RT711_CLK_FREQ_12000000HZ:
1141                 value = 0x0;
1142                 break;
1143         case RT711_CLK_FREQ_6000000HZ:
1144                 value = 0x1;
1145                 break;
1146         case RT711_CLK_FREQ_9600000HZ:
1147                 value = 0x2;
1148                 break;
1149         case RT711_CLK_FREQ_4800000HZ:
1150                 value = 0x3;
1151                 break;
1152         case RT711_CLK_FREQ_2400000HZ:
1153                 value = 0x4;
1154                 break;
1155         case RT711_CLK_FREQ_12288000HZ:
1156                 value = 0x5;
1157                 break;
1158         default:
1159                 return -EINVAL;
1160         }
1161
1162         regmap_write(rt711->regmap, 0xe0, value);
1163         regmap_write(rt711->regmap, 0xf0, value);
1164
1165         dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
1166
1167         return 0;
1168 }
1169
1170 static void rt711_calibration_work(struct work_struct *work)
1171 {
1172         struct rt711_priv *rt711 =
1173                 container_of(work, struct rt711_priv, calibration_work);
1174
1175         rt711_calibration(rt711);
1176 }
1177
1178 int rt711_init(struct device *dev, struct regmap *sdw_regmap,
1179                         struct regmap *regmap, struct sdw_slave *slave)
1180 {
1181         struct rt711_priv *rt711;
1182         int ret;
1183
1184         rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL);
1185         if (!rt711)
1186                 return -ENOMEM;
1187
1188         dev_set_drvdata(dev, rt711);
1189         rt711->slave = slave;
1190         rt711->sdw_regmap = sdw_regmap;
1191         rt711->regmap = regmap;
1192
1193         regcache_cache_only(rt711->regmap, true);
1194
1195         mutex_init(&rt711->calibrate_mutex);
1196         mutex_init(&rt711->disable_irq_lock);
1197
1198         INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_jack_detect_handler);
1199         INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_btn_check_handler);
1200         INIT_WORK(&rt711->calibration_work, rt711_calibration_work);
1201
1202         /*
1203          * Mark hw_init to false
1204          * HW init will be performed when device reports present
1205          */
1206         rt711->hw_init = false;
1207         rt711->first_hw_init = false;
1208
1209         /* JD source uses JD2 in default */
1210         rt711->jd_src = RT711_JD2;
1211
1212         ret =  devm_snd_soc_register_component(dev,
1213                                 &soc_codec_dev_rt711,
1214                                 rt711_dai,
1215                                 ARRAY_SIZE(rt711_dai));
1216         if (ret < 0)
1217                 return ret;
1218
1219         /* set autosuspend parameters */
1220         pm_runtime_set_autosuspend_delay(dev, 3000);
1221         pm_runtime_use_autosuspend(dev);
1222
1223         /* make sure the device does not suspend immediately */
1224         pm_runtime_mark_last_busy(dev);
1225
1226         pm_runtime_enable(dev);
1227
1228         /* important note: the device is NOT tagged as 'active' and will remain
1229          * 'suspended' until the hardware is enumerated/initialized. This is required
1230          * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently
1231          * fail with -EACCESS because of race conditions between card creation and enumeration
1232          */
1233
1234         dev_dbg(dev, "%s\n", __func__);
1235
1236         return ret;
1237 }
1238
1239 int rt711_io_init(struct device *dev, struct sdw_slave *slave)
1240 {
1241         struct rt711_priv *rt711 = dev_get_drvdata(dev);
1242
1243         rt711->disable_irq = false;
1244
1245         if (rt711->hw_init)
1246                 return 0;
1247
1248         regcache_cache_only(rt711->regmap, false);
1249         if (rt711->first_hw_init)
1250                 regcache_cache_bypass(rt711->regmap, true);
1251
1252         /*
1253          * PM runtime status is marked as 'active' only when a Slave reports as Attached
1254          */
1255         if (!rt711->first_hw_init)
1256                 /* update count of parent 'active' children */
1257                 pm_runtime_set_active(&slave->dev);
1258
1259         pm_runtime_get_noresume(&slave->dev);
1260
1261         rt711_reset(rt711->regmap);
1262
1263         /* power on */
1264         regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
1265
1266         /* Set Pin Widget */
1267         regmap_write(rt711->regmap, RT711_SET_PIN_MIC2, 0x25);
1268         regmap_write(rt711->regmap, RT711_SET_PIN_HP, 0xc0);
1269         regmap_write(rt711->regmap, RT711_SET_PIN_DMIC1, 0x20);
1270         regmap_write(rt711->regmap, RT711_SET_PIN_DMIC2, 0x20);
1271         regmap_write(rt711->regmap, RT711_SET_PIN_LINE1, 0x20);
1272         regmap_write(rt711->regmap, RT711_SET_PIN_LINE2, 0x20);
1273
1274         /* Mute HP/ADC1/ADC2 */
1275         regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0xa080);
1276         regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0x9080);
1277         regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x6080);
1278         regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x5080);
1279         regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x6080);
1280         regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x5080);
1281
1282         /* Set Configuration Default */
1283         regmap_write(rt711->regmap, 0x4f12, 0x91);
1284         regmap_write(rt711->regmap, 0x4e12, 0xd6);
1285         regmap_write(rt711->regmap, 0x4d12, 0x11);
1286         regmap_write(rt711->regmap, 0x4c12, 0x20);
1287         regmap_write(rt711->regmap, 0x4f13, 0x91);
1288         regmap_write(rt711->regmap, 0x4e13, 0xd6);
1289         regmap_write(rt711->regmap, 0x4d13, 0x11);
1290         regmap_write(rt711->regmap, 0x4c13, 0x21);
1291         regmap_write(rt711->regmap, 0x4c21, 0xf0);
1292         regmap_write(rt711->regmap, 0x4d21, 0x11);
1293         regmap_write(rt711->regmap, 0x4e21, 0x11);
1294         regmap_write(rt711->regmap, 0x4f21, 0x01);
1295
1296         /* Data port arrangement */
1297         rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
1298                 RT711_TX_RX_MUX_CTL, 0x0154);
1299
1300         /* Set index */
1301         rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
1302                 RT711_DIGITAL_MISC_CTRL4, 0x201b);
1303         rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
1304                 RT711_COMBO_JACK_AUTO_CTL1, 0x5089);
1305         rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
1306                 RT711_VREFOUT_CTL, 0x5064);
1307         rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
1308                 RT711_INLINE_CMD_CTL, 0xd249);
1309
1310         /* Finish Initial Settings, set power to D3 */
1311         regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
1312
1313         if (rt711->first_hw_init)
1314                 rt711_calibration(rt711);
1315         else
1316                 schedule_work(&rt711->calibration_work);
1317
1318         /*
1319          * if set_jack callback occurred early than io_init,
1320          * we set up the jack detection function now
1321          */
1322         if (rt711->hs_jack)
1323                 rt711_jack_init(rt711);
1324
1325         if (rt711->first_hw_init) {
1326                 regcache_cache_bypass(rt711->regmap, false);
1327                 regcache_mark_dirty(rt711->regmap);
1328         } else
1329                 rt711->first_hw_init = true;
1330
1331         /* Mark Slave initialization complete */
1332         rt711->hw_init = true;
1333
1334         pm_runtime_mark_last_busy(&slave->dev);
1335         pm_runtime_put_autosuspend(&slave->dev);
1336
1337         dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1338         return 0;
1339 }
1340
1341 MODULE_DESCRIPTION("ASoC RT711 SDW driver");
1342 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1343 MODULE_LICENSE("GPL");