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