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, ®); 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_put_autosuspend(component->dev); 484 485 return 0; 486 } 487 488 static void rt711_get_gain(struct rt711_priv *rt711, unsigned int addr_h, 489 unsigned int addr_l, unsigned int val_h, 490 unsigned int *r_val, unsigned int *l_val) 491 { 492 /* R Channel */ 493 *r_val = (val_h << 8); 494 regmap_read(rt711->regmap, addr_l, r_val); 495 496 /* L Channel */ 497 val_h |= 0x20; 498 *l_val = (val_h << 8); 499 regmap_read(rt711->regmap, addr_h, l_val); 500 } 501 502 /* For Verb-Set Amplifier Gain (Verb ID = 3h) */ 503 static int rt711_set_amp_gain_put(struct snd_kcontrol *kcontrol, 504 struct snd_ctl_elem_value *ucontrol) 505 { 506 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 507 struct snd_soc_dapm_context *dapm = 508 snd_soc_component_get_dapm(component); 509 struct soc_mixer_control *mc = 510 (struct soc_mixer_control *)kcontrol->private_value; 511 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 512 unsigned int addr_h, addr_l, val_h, val_ll, val_lr; 513 unsigned int read_ll, read_rl; 514 int i; 515 516 mutex_lock(&rt711->calibrate_mutex); 517 518 /* Can't use update bit function, so read the original value first */ 519 addr_h = mc->reg; 520 addr_l = mc->rreg; 521 if (mc->shift == RT711_DIR_OUT_SFT) /* output */ 522 val_h = 0x80; 523 else /* input */ 524 val_h = 0x0; 525 526 rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll); 527 528 /* L Channel */ 529 if (mc->invert) { 530 /* for mute/unmute */ 531 val_ll = (mc->max - ucontrol->value.integer.value[0]) 532 << RT711_MUTE_SFT; 533 /* keep gain */ 534 read_ll = read_ll & 0x7f; 535 val_ll |= read_ll; 536 } else { 537 /* for gain */ 538 val_ll = ((ucontrol->value.integer.value[0]) & 0x7f); 539 if (val_ll > mc->max) 540 val_ll = mc->max; 541 /* keep mute status */ 542 read_ll = read_ll & (1 << RT711_MUTE_SFT); 543 val_ll |= read_ll; 544 } 545 546 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 547 regmap_write(rt711->regmap, 548 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0); 549 550 /* R Channel */ 551 if (mc->invert) { 552 /* for mute/unmute */ 553 val_lr = (mc->max - ucontrol->value.integer.value[1]) 554 << RT711_MUTE_SFT; 555 /* keep gain */ 556 read_rl = read_rl & 0x7f; 557 val_lr |= read_rl; 558 } else { 559 /* for gain */ 560 val_lr = ((ucontrol->value.integer.value[1]) & 0x7f); 561 if (val_lr > mc->max) 562 val_lr = mc->max; 563 /* keep mute status */ 564 read_rl = read_rl & (1 << RT711_MUTE_SFT); 565 val_lr |= read_rl; 566 } 567 568 for (i = 0; i < 3; i++) { /* retry 3 times at most */ 569 570 if (val_ll == val_lr) { 571 /* Set both L/R channels at the same time */ 572 val_h = (1 << mc->shift) | (3 << 4); 573 regmap_write(rt711->regmap, 574 addr_h, (val_h << 8 | val_ll)); 575 regmap_write(rt711->regmap, 576 addr_l, (val_h << 8 | val_ll)); 577 } else { 578 /* Lch*/ 579 val_h = (1 << mc->shift) | (1 << 5); 580 regmap_write(rt711->regmap, 581 addr_h, (val_h << 8 | val_ll)); 582 583 /* Rch */ 584 val_h = (1 << mc->shift) | (1 << 4); 585 regmap_write(rt711->regmap, 586 addr_l, (val_h << 8 | val_lr)); 587 } 588 /* check result */ 589 if (mc->shift == RT711_DIR_OUT_SFT) /* output */ 590 val_h = 0x80; 591 else /* input */ 592 val_h = 0x0; 593 594 rt711_get_gain(rt711, addr_h, addr_l, val_h, 595 &read_rl, &read_ll); 596 if (read_rl == val_lr && read_ll == val_ll) 597 break; 598 } 599 600 if (dapm->bias_level <= SND_SOC_BIAS_STANDBY) 601 regmap_write(rt711->regmap, 602 RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3); 603 604 mutex_unlock(&rt711->calibrate_mutex); 605 return 0; 606 } 607 608 static int rt711_set_amp_gain_get(struct snd_kcontrol *kcontrol, 609 struct snd_ctl_elem_value *ucontrol) 610 { 611 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 612 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 613 struct soc_mixer_control *mc = 614 (struct soc_mixer_control *)kcontrol->private_value; 615 unsigned int addr_h, addr_l, val_h; 616 unsigned int read_ll, read_rl; 617 618 /* switch to get command */ 619 addr_h = mc->reg; 620 addr_l = mc->rreg; 621 if (mc->shift == RT711_DIR_OUT_SFT) /* output */ 622 val_h = 0x80; 623 else /* input */ 624 val_h = 0x0; 625 626 rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll); 627 628 if (mc->invert) { 629 /* mute/unmute for switch controls */ 630 read_ll = !((read_ll & 0x80) >> RT711_MUTE_SFT); 631 read_rl = !((read_rl & 0x80) >> RT711_MUTE_SFT); 632 } else { 633 /* for gain volume controls */ 634 read_ll = read_ll & 0x7f; 635 read_rl = read_rl & 0x7f; 636 } 637 ucontrol->value.integer.value[0] = read_ll; 638 ucontrol->value.integer.value[1] = read_rl; 639 640 return 0; 641 } 642 643 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0); 644 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0); 645 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0); 646 647 static const struct snd_kcontrol_new rt711_snd_controls[] = { 648 SOC_DOUBLE_R_EXT_TLV("DAC Surr Playback Volume", 649 RT711_SET_GAIN_DAC2_H, RT711_SET_GAIN_DAC2_L, 650 RT711_DIR_OUT_SFT, 0x57, 0, 651 rt711_set_amp_gain_get, rt711_set_amp_gain_put, out_vol_tlv), 652 SOC_DOUBLE_R_EXT("ADC 08 Capture Switch", 653 RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L, 654 RT711_DIR_IN_SFT, 1, 1, 655 rt711_set_amp_gain_get, rt711_set_amp_gain_put), 656 SOC_DOUBLE_R_EXT("ADC 09 Capture Switch", 657 RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L, 658 RT711_DIR_IN_SFT, 1, 1, 659 rt711_set_amp_gain_get, rt711_set_amp_gain_put), 660 SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume", 661 RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L, 662 RT711_DIR_IN_SFT, 0x3f, 0, 663 rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv), 664 SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume", 665 RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L, 666 RT711_DIR_IN_SFT, 0x3f, 0, 667 rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv), 668 SOC_DOUBLE_R_EXT_TLV("AMIC Volume", 669 RT711_SET_GAIN_AMIC_H, RT711_SET_GAIN_AMIC_L, 670 RT711_DIR_IN_SFT, 3, 0, 671 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv), 672 SOC_DOUBLE_R_EXT_TLV("DMIC1 Volume", 673 RT711_SET_GAIN_DMIC1_H, RT711_SET_GAIN_DMIC1_L, 674 RT711_DIR_IN_SFT, 3, 0, 675 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv), 676 SOC_DOUBLE_R_EXT_TLV("DMIC2 Volume", 677 RT711_SET_GAIN_DMIC2_H, RT711_SET_GAIN_DMIC2_L, 678 RT711_DIR_IN_SFT, 3, 0, 679 rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv), 680 }; 681 682 static int rt711_mux_get(struct snd_kcontrol *kcontrol, 683 struct snd_ctl_elem_value *ucontrol) 684 { 685 struct snd_soc_component *component = 686 snd_soc_dapm_kcontrol_component(kcontrol); 687 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 688 unsigned int reg, val = 0, nid; 689 int ret; 690 691 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 692 nid = RT711_MIXER_IN1; 693 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 694 nid = RT711_MIXER_IN2; 695 else 696 return -EINVAL; 697 698 /* vid = 0xf01 */ 699 reg = RT711_VERB_SET_CONNECT_SEL | nid; 700 ret = regmap_read(rt711->regmap, reg, &val); 701 if (ret < 0) { 702 dev_err(component->dev, "%s: sdw read failed: %d\n", 703 __func__, ret); 704 return ret; 705 } 706 707 ucontrol->value.enumerated.item[0] = val; 708 709 return 0; 710 } 711 712 static int rt711_mux_put(struct snd_kcontrol *kcontrol, 713 struct snd_ctl_elem_value *ucontrol) 714 { 715 struct snd_soc_component *component = 716 snd_soc_dapm_kcontrol_component(kcontrol); 717 struct snd_soc_dapm_context *dapm = 718 snd_soc_dapm_kcontrol_dapm(kcontrol); 719 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 720 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 721 unsigned int *item = ucontrol->value.enumerated.item; 722 unsigned int val, val2 = 0, change, reg, nid; 723 int ret; 724 725 if (item[0] >= e->items) 726 return -EINVAL; 727 728 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 729 nid = RT711_MIXER_IN1; 730 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 731 nid = RT711_MIXER_IN2; 732 else 733 return -EINVAL; 734 735 /* Verb ID = 0x701h */ 736 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 737 738 reg = RT711_VERB_SET_CONNECT_SEL | nid; 739 ret = regmap_read(rt711->regmap, reg, &val2); 740 if (ret < 0) { 741 dev_err(component->dev, "%s: sdw read failed: %d\n", 742 __func__, ret); 743 return ret; 744 } 745 746 if (val == val2) 747 change = 0; 748 else 749 change = 1; 750 751 if (change) { 752 reg = RT711_VERB_SET_CONNECT_SEL | nid; 753 regmap_write(rt711->regmap, reg, val); 754 } 755 756 snd_soc_dapm_mux_update_power(dapm, kcontrol, 757 item[0], e, NULL); 758 759 return change; 760 } 761 762 static const char * const adc_mux_text[] = { 763 "MIC2", 764 "LINE1", 765 "LINE2", 766 "DMIC", 767 }; 768 769 static SOC_ENUM_SINGLE_DECL( 770 rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text); 771 772 static SOC_ENUM_SINGLE_DECL( 773 rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text); 774 775 static const struct snd_kcontrol_new rt711_adc22_mux = 776 SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum, 777 rt711_mux_get, rt711_mux_put); 778 779 static const struct snd_kcontrol_new rt711_adc23_mux = 780 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum, 781 rt711_mux_get, rt711_mux_put); 782 783 static int rt711_dac_surround_event(struct snd_soc_dapm_widget *w, 784 struct snd_kcontrol *kcontrol, int event) 785 { 786 struct snd_soc_component *component = 787 snd_soc_dapm_to_component(w->dapm); 788 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 789 unsigned int val_h = (1 << RT711_DIR_OUT_SFT) | (0x3 << 4); 790 unsigned int val_l; 791 792 switch (event) { 793 case SND_SOC_DAPM_POST_PMU: 794 regmap_write(rt711->regmap, 795 RT711_SET_STREAMID_DAC2, 0x10); 796 797 val_l = 0x00; 798 regmap_write(rt711->regmap, 799 RT711_SET_GAIN_HP_H, (val_h << 8 | val_l)); 800 break; 801 case SND_SOC_DAPM_PRE_PMD: 802 val_l = (1 << RT711_MUTE_SFT); 803 regmap_write(rt711->regmap, 804 RT711_SET_GAIN_HP_H, (val_h << 8 | val_l)); 805 usleep_range(50000, 55000); 806 807 regmap_write(rt711->regmap, 808 RT711_SET_STREAMID_DAC2, 0x00); 809 break; 810 } 811 return 0; 812 } 813 814 static int rt711_adc_09_event(struct snd_soc_dapm_widget *w, 815 struct snd_kcontrol *kcontrol, int event) 816 { 817 struct snd_soc_component *component = 818 snd_soc_dapm_to_component(w->dapm); 819 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 820 821 switch (event) { 822 case SND_SOC_DAPM_POST_PMU: 823 regmap_write(rt711->regmap, 824 RT711_SET_STREAMID_ADC1, 0x10); 825 break; 826 case SND_SOC_DAPM_PRE_PMD: 827 regmap_write(rt711->regmap, 828 RT711_SET_STREAMID_ADC1, 0x00); 829 break; 830 } 831 return 0; 832 } 833 834 static int rt711_adc_08_event(struct snd_soc_dapm_widget *w, 835 struct snd_kcontrol *kcontrol, int event) 836 { 837 struct snd_soc_component *component = 838 snd_soc_dapm_to_component(w->dapm); 839 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 840 841 switch (event) { 842 case SND_SOC_DAPM_POST_PMU: 843 regmap_write(rt711->regmap, 844 RT711_SET_STREAMID_ADC2, 0x10); 845 break; 846 case SND_SOC_DAPM_PRE_PMD: 847 regmap_write(rt711->regmap, 848 RT711_SET_STREAMID_ADC2, 0x00); 849 break; 850 } 851 return 0; 852 } 853 854 static const struct snd_soc_dapm_widget rt711_dapm_widgets[] = { 855 SND_SOC_DAPM_OUTPUT("HP"), 856 SND_SOC_DAPM_INPUT("MIC2"), 857 SND_SOC_DAPM_INPUT("DMIC1"), 858 SND_SOC_DAPM_INPUT("DMIC2"), 859 SND_SOC_DAPM_INPUT("LINE1"), 860 SND_SOC_DAPM_INPUT("LINE2"), 861 862 SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0, 863 rt711_dac_surround_event, 864 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 865 SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0, 866 rt711_adc_09_event, 867 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 868 SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0, 869 rt711_adc_08_event, 870 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 871 SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0, 872 &rt711_adc22_mux), 873 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0, 874 &rt711_adc23_mux), 875 876 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 877 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0), 878 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0), 879 }; 880 881 static const struct snd_soc_dapm_route rt711_audio_map[] = { 882 {"DAC Surround", NULL, "DP3RX"}, 883 {"DP2TX", NULL, "ADC 09"}, 884 {"DP4TX", NULL, "ADC 08"}, 885 886 {"ADC 09", NULL, "ADC 22 Mux"}, 887 {"ADC 08", NULL, "ADC 23 Mux"}, 888 {"ADC 22 Mux", "DMIC", "DMIC1"}, 889 {"ADC 22 Mux", "LINE1", "LINE1"}, 890 {"ADC 22 Mux", "LINE2", "LINE2"}, 891 {"ADC 22 Mux", "MIC2", "MIC2"}, 892 {"ADC 23 Mux", "DMIC", "DMIC2"}, 893 {"ADC 23 Mux", "LINE1", "LINE1"}, 894 {"ADC 23 Mux", "LINE2", "LINE2"}, 895 {"ADC 23 Mux", "MIC2", "MIC2"}, 896 897 {"HP", NULL, "DAC Surround"}, 898 }; 899 900 static int rt711_set_bias_level(struct snd_soc_component *component, 901 enum snd_soc_bias_level level) 902 { 903 struct snd_soc_dapm_context *dapm = 904 snd_soc_component_get_dapm(component); 905 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 906 907 switch (level) { 908 case SND_SOC_BIAS_PREPARE: 909 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) { 910 regmap_write(rt711->regmap, 911 RT711_SET_AUDIO_POWER_STATE, 912 AC_PWRST_D0); 913 } 914 break; 915 916 case SND_SOC_BIAS_STANDBY: 917 mutex_lock(&rt711->calibrate_mutex); 918 regmap_write(rt711->regmap, 919 RT711_SET_AUDIO_POWER_STATE, 920 AC_PWRST_D3); 921 mutex_unlock(&rt711->calibrate_mutex); 922 break; 923 924 default: 925 break; 926 } 927 928 return 0; 929 } 930 931 static int rt711_parse_dt(struct rt711_priv *rt711, struct device *dev) 932 { 933 device_property_read_u32(dev, "realtek,jd-src", 934 &rt711->jd_src); 935 936 return 0; 937 } 938 939 static int rt711_probe(struct snd_soc_component *component) 940 { 941 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 942 int ret; 943 944 rt711_parse_dt(rt711, &rt711->slave->dev); 945 rt711->component = component; 946 947 if (!rt711->first_hw_init) 948 return 0; 949 950 ret = pm_runtime_resume(component->dev); 951 if (ret < 0 && ret != -EACCES) 952 return ret; 953 954 return 0; 955 } 956 957 static const struct snd_soc_component_driver soc_codec_dev_rt711 = { 958 .probe = rt711_probe, 959 .set_bias_level = rt711_set_bias_level, 960 .controls = rt711_snd_controls, 961 .num_controls = ARRAY_SIZE(rt711_snd_controls), 962 .dapm_widgets = rt711_dapm_widgets, 963 .num_dapm_widgets = ARRAY_SIZE(rt711_dapm_widgets), 964 .dapm_routes = rt711_audio_map, 965 .num_dapm_routes = ARRAY_SIZE(rt711_audio_map), 966 .set_jack = rt711_set_jack_detect, 967 .endianness = 1, 968 }; 969 970 static int rt711_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 971 int direction) 972 { 973 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 974 975 return 0; 976 } 977 978 static void rt711_shutdown(struct snd_pcm_substream *substream, 979 struct snd_soc_dai *dai) 980 { 981 snd_soc_dai_set_dma_data(dai, substream, NULL); 982 } 983 984 static int rt711_pcm_hw_params(struct snd_pcm_substream *substream, 985 struct snd_pcm_hw_params *params, 986 struct snd_soc_dai *dai) 987 { 988 struct snd_soc_component *component = dai->component; 989 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 990 struct sdw_stream_config stream_config = {0}; 991 struct sdw_port_config port_config = {0}; 992 struct sdw_stream_runtime *sdw_stream; 993 int retval; 994 unsigned int val = 0; 995 996 dev_dbg(dai->dev, "%s %s", __func__, dai->name); 997 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 998 999 if (!sdw_stream) 1000 return -EINVAL; 1001 1002 if (!rt711->slave) 1003 return -EINVAL; 1004 1005 /* SoundWire specific configuration */ 1006 snd_sdw_params_to_config(substream, params, &stream_config, &port_config); 1007 1008 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1009 port_config.num = 3; 1010 } else { 1011 if (dai->id == RT711_AIF1) 1012 port_config.num = 4; 1013 else if (dai->id == RT711_AIF2) 1014 port_config.num = 2; 1015 else 1016 return -EINVAL; 1017 } 1018 1019 retval = sdw_stream_add_slave(rt711->slave, &stream_config, 1020 &port_config, 1, sdw_stream); 1021 if (retval) { 1022 dev_err(dai->dev, "%s: Unable to configure port\n", __func__); 1023 return retval; 1024 } 1025 1026 if (params_channels(params) <= 16) { 1027 /* bit 3:0 Number of Channel */ 1028 val |= (params_channels(params) - 1); 1029 } else { 1030 dev_err(component->dev, "%s: Unsupported channels %d\n", 1031 __func__, params_channels(params)); 1032 return -EINVAL; 1033 } 1034 1035 switch (params_width(params)) { 1036 /* bit 6:4 Bits per Sample */ 1037 case 8: 1038 break; 1039 case 16: 1040 val |= (0x1 << 4); 1041 break; 1042 case 20: 1043 val |= (0x2 << 4); 1044 break; 1045 case 24: 1046 val |= (0x3 << 4); 1047 break; 1048 case 32: 1049 val |= (0x4 << 4); 1050 break; 1051 default: 1052 return -EINVAL; 1053 } 1054 1055 /* 48Khz */ 1056 regmap_write(rt711->regmap, RT711_DAC_FORMAT_H, val); 1057 regmap_write(rt711->regmap, RT711_ADC1_FORMAT_H, val); 1058 regmap_write(rt711->regmap, RT711_ADC2_FORMAT_H, val); 1059 1060 return retval; 1061 } 1062 1063 static int rt711_pcm_hw_free(struct snd_pcm_substream *substream, 1064 struct snd_soc_dai *dai) 1065 { 1066 struct snd_soc_component *component = dai->component; 1067 struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component); 1068 struct sdw_stream_runtime *sdw_stream = 1069 snd_soc_dai_get_dma_data(dai, substream); 1070 1071 if (!rt711->slave) 1072 return -EINVAL; 1073 1074 sdw_stream_remove_slave(rt711->slave, sdw_stream); 1075 return 0; 1076 } 1077 1078 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000) 1079 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \ 1080 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8) 1081 1082 static const struct snd_soc_dai_ops rt711_ops = { 1083 .hw_params = rt711_pcm_hw_params, 1084 .hw_free = rt711_pcm_hw_free, 1085 .set_stream = rt711_set_sdw_stream, 1086 .shutdown = rt711_shutdown, 1087 }; 1088 1089 static struct snd_soc_dai_driver rt711_dai[] = { 1090 { 1091 .name = "rt711-aif1", 1092 .id = RT711_AIF1, 1093 .playback = { 1094 .stream_name = "DP3 Playback", 1095 .channels_min = 1, 1096 .channels_max = 2, 1097 .rates = RT711_STEREO_RATES, 1098 .formats = RT711_FORMATS, 1099 }, 1100 .capture = { 1101 .stream_name = "DP4 Capture", 1102 .channels_min = 1, 1103 .channels_max = 2, 1104 .rates = RT711_STEREO_RATES, 1105 .formats = RT711_FORMATS, 1106 }, 1107 .ops = &rt711_ops, 1108 }, 1109 { 1110 .name = "rt711-aif2", 1111 .id = RT711_AIF2, 1112 .capture = { 1113 .stream_name = "DP2 Capture", 1114 .channels_min = 1, 1115 .channels_max = 2, 1116 .rates = RT711_STEREO_RATES, 1117 .formats = RT711_FORMATS, 1118 }, 1119 .ops = &rt711_ops, 1120 } 1121 }; 1122 1123 /* Bus clock frequency */ 1124 #define RT711_CLK_FREQ_9600000HZ 9600000 1125 #define RT711_CLK_FREQ_12000000HZ 12000000 1126 #define RT711_CLK_FREQ_6000000HZ 6000000 1127 #define RT711_CLK_FREQ_4800000HZ 4800000 1128 #define RT711_CLK_FREQ_2400000HZ 2400000 1129 #define RT711_CLK_FREQ_12288000HZ 12288000 1130 1131 int rt711_clock_config(struct device *dev) 1132 { 1133 struct rt711_priv *rt711 = dev_get_drvdata(dev); 1134 unsigned int clk_freq, value; 1135 1136 clk_freq = (rt711->params.curr_dr_freq >> 1); 1137 1138 switch (clk_freq) { 1139 case RT711_CLK_FREQ_12000000HZ: 1140 value = 0x0; 1141 break; 1142 case RT711_CLK_FREQ_6000000HZ: 1143 value = 0x1; 1144 break; 1145 case RT711_CLK_FREQ_9600000HZ: 1146 value = 0x2; 1147 break; 1148 case RT711_CLK_FREQ_4800000HZ: 1149 value = 0x3; 1150 break; 1151 case RT711_CLK_FREQ_2400000HZ: 1152 value = 0x4; 1153 break; 1154 case RT711_CLK_FREQ_12288000HZ: 1155 value = 0x5; 1156 break; 1157 default: 1158 return -EINVAL; 1159 } 1160 1161 regmap_write(rt711->regmap, 0xe0, value); 1162 regmap_write(rt711->regmap, 0xf0, value); 1163 1164 dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq); 1165 1166 return 0; 1167 } 1168 1169 static void rt711_calibration_work(struct work_struct *work) 1170 { 1171 struct rt711_priv *rt711 = 1172 container_of(work, struct rt711_priv, calibration_work); 1173 1174 rt711_calibration(rt711); 1175 } 1176 1177 int rt711_init(struct device *dev, struct regmap *sdw_regmap, 1178 struct regmap *regmap, struct sdw_slave *slave) 1179 { 1180 struct rt711_priv *rt711; 1181 int ret; 1182 1183 rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL); 1184 if (!rt711) 1185 return -ENOMEM; 1186 1187 dev_set_drvdata(dev, rt711); 1188 rt711->slave = slave; 1189 rt711->sdw_regmap = sdw_regmap; 1190 rt711->regmap = regmap; 1191 1192 regcache_cache_only(rt711->regmap, true); 1193 1194 mutex_init(&rt711->calibrate_mutex); 1195 mutex_init(&rt711->disable_irq_lock); 1196 1197 INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_jack_detect_handler); 1198 INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_btn_check_handler); 1199 INIT_WORK(&rt711->calibration_work, rt711_calibration_work); 1200 1201 /* 1202 * Mark hw_init to false 1203 * HW init will be performed when device reports present 1204 */ 1205 rt711->hw_init = false; 1206 rt711->first_hw_init = false; 1207 1208 /* JD source uses JD2 in default */ 1209 rt711->jd_src = RT711_JD2; 1210 1211 ret = devm_snd_soc_register_component(dev, 1212 &soc_codec_dev_rt711, 1213 rt711_dai, 1214 ARRAY_SIZE(rt711_dai)); 1215 if (ret < 0) 1216 return ret; 1217 1218 /* set autosuspend parameters */ 1219 pm_runtime_set_autosuspend_delay(dev, 3000); 1220 pm_runtime_use_autosuspend(dev); 1221 1222 /* make sure the device does not suspend immediately */ 1223 pm_runtime_mark_last_busy(dev); 1224 1225 pm_runtime_enable(dev); 1226 1227 /* important note: the device is NOT tagged as 'active' and will remain 1228 * 'suspended' until the hardware is enumerated/initialized. This is required 1229 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently 1230 * fail with -EACCESS because of race conditions between card creation and enumeration 1231 */ 1232 1233 dev_dbg(dev, "%s\n", __func__); 1234 1235 return ret; 1236 } 1237 1238 int rt711_io_init(struct device *dev, struct sdw_slave *slave) 1239 { 1240 struct rt711_priv *rt711 = dev_get_drvdata(dev); 1241 1242 rt711->disable_irq = false; 1243 1244 if (rt711->hw_init) 1245 return 0; 1246 1247 regcache_cache_only(rt711->regmap, false); 1248 if (rt711->first_hw_init) 1249 regcache_cache_bypass(rt711->regmap, true); 1250 1251 /* 1252 * PM runtime status is marked as 'active' only when a Slave reports as Attached 1253 */ 1254 if (!rt711->first_hw_init) 1255 /* update count of parent 'active' children */ 1256 pm_runtime_set_active(&slave->dev); 1257 1258 pm_runtime_get_noresume(&slave->dev); 1259 1260 rt711_reset(rt711->regmap); 1261 1262 /* power on */ 1263 regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0); 1264 1265 /* Set Pin Widget */ 1266 regmap_write(rt711->regmap, RT711_SET_PIN_MIC2, 0x25); 1267 regmap_write(rt711->regmap, RT711_SET_PIN_HP, 0xc0); 1268 regmap_write(rt711->regmap, RT711_SET_PIN_DMIC1, 0x20); 1269 regmap_write(rt711->regmap, RT711_SET_PIN_DMIC2, 0x20); 1270 regmap_write(rt711->regmap, RT711_SET_PIN_LINE1, 0x20); 1271 regmap_write(rt711->regmap, RT711_SET_PIN_LINE2, 0x20); 1272 1273 /* Mute HP/ADC1/ADC2 */ 1274 regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0xa080); 1275 regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0x9080); 1276 regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x6080); 1277 regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x5080); 1278 regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x6080); 1279 regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x5080); 1280 1281 /* Set Configuration Default */ 1282 regmap_write(rt711->regmap, 0x4f12, 0x91); 1283 regmap_write(rt711->regmap, 0x4e12, 0xd6); 1284 regmap_write(rt711->regmap, 0x4d12, 0x11); 1285 regmap_write(rt711->regmap, 0x4c12, 0x20); 1286 regmap_write(rt711->regmap, 0x4f13, 0x91); 1287 regmap_write(rt711->regmap, 0x4e13, 0xd6); 1288 regmap_write(rt711->regmap, 0x4d13, 0x11); 1289 regmap_write(rt711->regmap, 0x4c13, 0x21); 1290 regmap_write(rt711->regmap, 0x4c21, 0xf0); 1291 regmap_write(rt711->regmap, 0x4d21, 0x11); 1292 regmap_write(rt711->regmap, 0x4e21, 0x11); 1293 regmap_write(rt711->regmap, 0x4f21, 0x01); 1294 1295 /* Data port arrangement */ 1296 rt711_index_write(rt711->regmap, RT711_VENDOR_REG, 1297 RT711_TX_RX_MUX_CTL, 0x0154); 1298 1299 /* Set index */ 1300 rt711_index_write(rt711->regmap, RT711_VENDOR_REG, 1301 RT711_DIGITAL_MISC_CTRL4, 0x201b); 1302 rt711_index_write(rt711->regmap, RT711_VENDOR_REG, 1303 RT711_COMBO_JACK_AUTO_CTL1, 0x5089); 1304 rt711_index_write(rt711->regmap, RT711_VENDOR_REG, 1305 RT711_VREFOUT_CTL, 0x5064); 1306 rt711_index_write(rt711->regmap, RT711_VENDOR_REG, 1307 RT711_INLINE_CMD_CTL, 0xd249); 1308 1309 /* Finish Initial Settings, set power to D3 */ 1310 regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3); 1311 1312 if (rt711->first_hw_init) 1313 rt711_calibration(rt711); 1314 else 1315 schedule_work(&rt711->calibration_work); 1316 1317 /* 1318 * if set_jack callback occurred early than io_init, 1319 * we set up the jack detection function now 1320 */ 1321 if (rt711->hs_jack) 1322 rt711_jack_init(rt711); 1323 1324 if (rt711->first_hw_init) { 1325 regcache_cache_bypass(rt711->regmap, false); 1326 regcache_mark_dirty(rt711->regmap); 1327 } else 1328 rt711->first_hw_init = true; 1329 1330 /* Mark Slave initialization complete */ 1331 rt711->hw_init = true; 1332 1333 pm_runtime_put_autosuspend(&slave->dev); 1334 1335 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1336 return 0; 1337 } 1338 1339 MODULE_DESCRIPTION("ASoC RT711 SDW driver"); 1340 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1341 MODULE_LICENSE("GPL"); 1342