1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // rt711-sdca.c -- rt711 SDCA ALSA SoC audio driver 4 // 5 // Copyright(c) 2021 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/soundwire/sdw_registers.h> 16 #include <linux/slab.h> 17 #include <linux/bitops.h> 18 #include <sound/core.h> 19 #include <sound/pcm.h> 20 #include <sound/pcm_params.h> 21 #include <sound/sdw.h> 22 #include <sound/soc-dapm.h> 23 #include <sound/initval.h> 24 #include <sound/tlv.h> 25 #include <sound/jack.h> 26 27 #include "rt711-sdca.h" 28 29 static int rt711_sdca_index_write(struct rt711_sdca_priv *rt711, 30 unsigned int nid, unsigned int reg, unsigned int value) 31 { 32 int ret; 33 struct regmap *regmap = rt711->mbq_regmap; 34 unsigned int addr = (nid << 20) | reg; 35 36 ret = regmap_write(regmap, addr, value); 37 if (ret < 0) 38 dev_err(&rt711->slave->dev, 39 "%s: Failed to set private value: %06x <= %04x ret=%d\n", 40 __func__, addr, value, ret); 41 42 return ret; 43 } 44 45 static int rt711_sdca_index_read(struct rt711_sdca_priv *rt711, 46 unsigned int nid, unsigned int reg, unsigned int *value) 47 { 48 int ret; 49 struct regmap *regmap = rt711->mbq_regmap; 50 unsigned int addr = (nid << 20) | reg; 51 52 ret = regmap_read(regmap, addr, value); 53 if (ret < 0) 54 dev_err(&rt711->slave->dev, 55 "%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_sdca_index_update_bits(struct rt711_sdca_priv *rt711, 62 unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val) 63 { 64 unsigned int tmp; 65 int ret; 66 67 ret = rt711_sdca_index_read(rt711, nid, reg, &tmp); 68 if (ret < 0) 69 return ret; 70 71 set_mask_bits(&tmp, mask, val); 72 return rt711_sdca_index_write(rt711, nid, reg, tmp); 73 } 74 75 static void rt711_sdca_reset(struct rt711_sdca_priv *rt711) 76 { 77 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 78 RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET, 79 RT711_HIDDEN_REG_SW_RESET); 80 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 81 RT711_HDA_LEGACY_RESET_CTL, 0x1, 0x1); 82 } 83 84 static void rt711_sdca_ge_force_jack_type(struct rt711_sdca_priv *rt711, unsigned int det_mode) 85 { 86 switch (det_mode) { 87 case 0x00: 88 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x0000); 89 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x10, 0x00); 90 break; 91 case 0x03: 92 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8000); 93 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x13); 94 break; 95 case 0x05: 96 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8400); 97 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x15); 98 break; 99 } 100 } 101 102 static int rt711_sdca_calibration(struct rt711_sdca_priv *rt711) 103 { 104 unsigned int val, loop_rc = 0, loop_dc = 0; 105 struct device *dev; 106 struct regmap *regmap = rt711->regmap; 107 int chk_cnt = 100; 108 int ret = 0; 109 110 mutex_lock(&rt711->calibrate_mutex); 111 dev = regmap_get_device(regmap); 112 113 regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val); 114 /* RC calibration */ 115 if (!(val & 0x40)) 116 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL, 117 RT711_MISC_POWER_CTL0, 0x0010, 0x0010); 118 119 for (loop_rc = 0; loop_rc < chk_cnt && !(val & 0x40); loop_rc++) { 120 usleep_range(10000, 11000); 121 ret = regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val); 122 if (ret < 0) 123 goto _cali_fail_; 124 } 125 if (loop_rc == chk_cnt) 126 dev_err(dev, "%s, RC calibration time-out!\n", __func__); 127 128 /* HP calibration by manual mode setting */ 129 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 130 RT711_FSM_CTL, 0x2000, 0x2000); 131 132 /* Calibration manual mode */ 133 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 134 RT711_FSM_CTL, 0xf, RT711_CALI_CTL); 135 136 /* reset HP calibration */ 137 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI, 138 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST, 0x00); 139 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI, 140 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST, 141 RT711_DAC_DC_FORCE_CALI_RST); 142 143 /* cal_clk_en_reg */ 144 if (rt711->hw_ver == RT711_VER_VD0) 145 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI, 146 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_CLK_EN, 147 RT711_DAC_DC_CALI_CLK_EN); 148 149 /* trigger */ 150 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI, 151 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER, 152 RT711_DAC_DC_CALI_TRIGGER); 153 154 /* wait for calibration process */ 155 rt711_sdca_index_read(rt711, RT711_VENDOR_CALI, 156 RT711_DAC_DC_CALI_CTL1, &val); 157 158 for (loop_dc = 0; loop_dc < chk_cnt && 159 (val & RT711_DAC_DC_CALI_TRIGGER); loop_dc++) { 160 usleep_range(10000, 11000); 161 ret = rt711_sdca_index_read(rt711, RT711_VENDOR_CALI, 162 RT711_DAC_DC_CALI_CTL1, &val); 163 if (ret < 0) 164 goto _cali_fail_; 165 } 166 if (loop_dc == chk_cnt) 167 dev_err(dev, "%s, calibration time-out!\n", __func__); 168 169 if (loop_dc == chk_cnt || loop_rc == chk_cnt) 170 ret = -ETIMEDOUT; 171 172 _cali_fail_: 173 /* enable impedance sense */ 174 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 175 RT711_FSM_CTL, RT711_FSM_IMP_EN, RT711_FSM_IMP_EN); 176 177 /* release HP-JD and trigger FSM */ 178 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 179 RT711_DIGITAL_MISC_CTRL4, 0x201b); 180 181 mutex_unlock(&rt711->calibrate_mutex); 182 dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret); 183 return ret; 184 } 185 186 static unsigned int rt711_sdca_button_detect(struct rt711_sdca_priv *rt711) 187 { 188 unsigned int btn_type = 0, offset, idx, val, owner; 189 int ret; 190 unsigned char buf[3]; 191 192 /* get current UMP message owner */ 193 ret = regmap_read(rt711->regmap, 194 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0), 195 &owner); 196 if (ret < 0) 197 return 0; 198 199 /* if owner is device then there is no button event from device */ 200 if (owner == 1) 201 return 0; 202 203 /* read UMP message offset */ 204 ret = regmap_read(rt711->regmap, 205 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0), 206 &offset); 207 if (ret < 0) 208 goto _end_btn_det_; 209 210 for (idx = 0; idx < sizeof(buf); idx++) { 211 ret = regmap_read(rt711->regmap, 212 RT711_BUF_ADDR_HID1 + offset + idx, &val); 213 if (ret < 0) 214 goto _end_btn_det_; 215 buf[idx] = val & 0xff; 216 } 217 218 if (buf[0] == 0x11) { 219 switch (buf[1] & 0xf0) { 220 case 0x10: 221 btn_type |= SND_JACK_BTN_2; 222 break; 223 case 0x20: 224 btn_type |= SND_JACK_BTN_3; 225 break; 226 case 0x40: 227 btn_type |= SND_JACK_BTN_0; 228 break; 229 case 0x80: 230 btn_type |= SND_JACK_BTN_1; 231 break; 232 } 233 switch (buf[2]) { 234 case 0x01: 235 case 0x10: 236 btn_type |= SND_JACK_BTN_2; 237 break; 238 case 0x02: 239 case 0x20: 240 btn_type |= SND_JACK_BTN_3; 241 break; 242 case 0x04: 243 case 0x40: 244 btn_type |= SND_JACK_BTN_0; 245 break; 246 case 0x08: 247 case 0x80: 248 btn_type |= SND_JACK_BTN_1; 249 break; 250 } 251 } 252 253 _end_btn_det_: 254 /* Host is owner, so set back to device */ 255 if (owner == 0) 256 /* set owner to device */ 257 regmap_write(rt711->regmap, 258 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, 259 RT711_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01); 260 261 return btn_type; 262 } 263 264 static int rt711_sdca_headset_detect(struct rt711_sdca_priv *rt711) 265 { 266 unsigned int det_mode; 267 int ret; 268 269 rt711_sdca_ge_force_jack_type(rt711, rt711->ge_mode_override); 270 271 /* get detected_mode */ 272 ret = regmap_read(rt711->regmap, 273 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0), 274 &det_mode); 275 if (ret < 0) 276 goto io_error; 277 278 switch (det_mode) { 279 case 0x00: 280 rt711->jack_type = 0; 281 break; 282 case 0x03: 283 rt711->jack_type = SND_JACK_HEADPHONE; 284 break; 285 case 0x05: 286 rt711->jack_type = SND_JACK_HEADSET; 287 break; 288 } 289 290 /* write selected_mode */ 291 if (det_mode) { 292 ret = regmap_write(rt711->regmap, 293 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_SELECTED_MODE, 0), 294 det_mode); 295 if (ret < 0) 296 goto io_error; 297 } 298 299 dev_dbg(&rt711->slave->dev, 300 "%s, detected_mode=0x%x\n", __func__, det_mode); 301 302 return 0; 303 304 io_error: 305 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 306 return ret; 307 } 308 309 static void rt711_sdca_jack_detect_handler(struct work_struct *work) 310 { 311 struct rt711_sdca_priv *rt711 = 312 container_of(work, struct rt711_sdca_priv, jack_detect_work.work); 313 int btn_type = 0, ret; 314 315 if (!rt711->hs_jack) 316 return; 317 318 if (!snd_soc_card_is_instantiated(rt711->component->card)) 319 return; 320 321 /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */ 322 if (rt711->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) { 323 ret = rt711_sdca_headset_detect(rt711); 324 if (ret < 0) 325 return; 326 } 327 328 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */ 329 if (rt711->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8) 330 btn_type = rt711_sdca_button_detect(rt711); 331 332 if (rt711->jack_type == 0) 333 btn_type = 0; 334 335 dev_dbg(&rt711->slave->dev, 336 "in %s, jack_type=0x%x\n", __func__, rt711->jack_type); 337 dev_dbg(&rt711->slave->dev, 338 "in %s, btn_type=0x%x\n", __func__, btn_type); 339 dev_dbg(&rt711->slave->dev, 340 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__, 341 rt711->scp_sdca_stat1, rt711->scp_sdca_stat2); 342 343 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type, 344 SND_JACK_HEADSET | 345 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 346 SND_JACK_BTN_2 | SND_JACK_BTN_3); 347 348 if (btn_type) { 349 /* button released */ 350 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type, 351 SND_JACK_HEADSET | 352 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 353 SND_JACK_BTN_2 | SND_JACK_BTN_3); 354 355 mod_delayed_work(system_power_efficient_wq, 356 &rt711->jack_btn_check_work, msecs_to_jiffies(200)); 357 } 358 } 359 360 static void rt711_sdca_btn_check_handler(struct work_struct *work) 361 { 362 struct rt711_sdca_priv *rt711 = 363 container_of(work, struct rt711_sdca_priv, jack_btn_check_work.work); 364 int btn_type = 0, ret, idx; 365 unsigned int det_mode, offset, val; 366 unsigned char buf[3]; 367 368 ret = regmap_read(rt711->regmap, 369 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0), 370 &det_mode); 371 if (ret < 0) 372 goto io_error; 373 374 /* pin attached */ 375 if (det_mode) { 376 /* read UMP message offset */ 377 ret = regmap_read(rt711->regmap, 378 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0), 379 &offset); 380 if (ret < 0) 381 goto io_error; 382 383 for (idx = 0; idx < sizeof(buf); idx++) { 384 ret = regmap_read(rt711->regmap, 385 RT711_BUF_ADDR_HID1 + offset + idx, &val); 386 if (ret < 0) 387 goto io_error; 388 buf[idx] = val & 0xff; 389 } 390 391 if (buf[0] == 0x11) { 392 switch (buf[1] & 0xf0) { 393 case 0x10: 394 btn_type |= SND_JACK_BTN_2; 395 break; 396 case 0x20: 397 btn_type |= SND_JACK_BTN_3; 398 break; 399 case 0x40: 400 btn_type |= SND_JACK_BTN_0; 401 break; 402 case 0x80: 403 btn_type |= SND_JACK_BTN_1; 404 break; 405 } 406 switch (buf[2]) { 407 case 0x01: 408 case 0x10: 409 btn_type |= SND_JACK_BTN_2; 410 break; 411 case 0x02: 412 case 0x20: 413 btn_type |= SND_JACK_BTN_3; 414 break; 415 case 0x04: 416 case 0x40: 417 btn_type |= SND_JACK_BTN_0; 418 break; 419 case 0x08: 420 case 0x80: 421 btn_type |= SND_JACK_BTN_1; 422 break; 423 } 424 } 425 } else 426 rt711->jack_type = 0; 427 428 dev_dbg(&rt711->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type); 429 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type, 430 SND_JACK_HEADSET | 431 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 432 SND_JACK_BTN_2 | SND_JACK_BTN_3); 433 434 if (btn_type) { 435 /* button released */ 436 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type, 437 SND_JACK_HEADSET | 438 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 439 SND_JACK_BTN_2 | SND_JACK_BTN_3); 440 441 mod_delayed_work(system_power_efficient_wq, 442 &rt711->jack_btn_check_work, msecs_to_jiffies(200)); 443 } 444 445 return; 446 447 io_error: 448 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 449 } 450 451 static void rt711_sdca_jack_init(struct rt711_sdca_priv *rt711) 452 { 453 mutex_lock(&rt711->calibrate_mutex); 454 455 if (rt711->hs_jack) { 456 /* Enable HID1 event & set button RTC mode */ 457 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 458 RT711_PUSH_BTN_INT_CTL6, 0x80f0, 0x8000); 459 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 460 RT711_PUSH_BTN_INT_CTL2, 0x11dd, 0x11dd); 461 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 462 RT711_PUSH_BTN_INT_CTL7, 0xffff); 463 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 464 RT711_PUSH_BTN_INT_CTL9, 0xf000, 0x0000); 465 466 /* GE_mode_change_event_en & Hid1_push_button_event_en */ 467 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 468 RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0c00); 469 470 switch (rt711->jd_src) { 471 case RT711_JD1: 472 /* default settings was already for JD1 */ 473 break; 474 case RT711_JD2: 475 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 476 RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL, 477 RT711_JD2_DIGITAL_MODE_SEL); 478 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 479 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2, 480 RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2); 481 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 482 RT711_CC_DET1, 483 RT711_HP_JD_FINAL_RESULT_CTL_JD12, 484 RT711_HP_JD_FINAL_RESULT_CTL_JD12); 485 break; 486 case RT711_JD2_100K: 487 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 488 RT711_COMBO_JACK_AUTO_CTL3, 0xa47e); 489 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 490 RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL, 491 RT711_JD2_DIGITAL_MODE_SEL); 492 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 493 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP | 494 RT711_JD2_2PORT_100K_DECODE_MASK | RT711_HP_JD_SEL_JD2, 495 RT711_JD2_2PORT_100K_DECODE_HP | RT711_HP_JD_SEL_JD2); 496 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 497 RT711_CC_DET1, 498 RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI, 499 RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI_OFF); 500 break; 501 default: 502 dev_warn(rt711->component->dev, "Wrong JD source\n"); 503 break; 504 } 505 506 /* set SCP_SDCA_IntMask1[0]=1 */ 507 sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0); 508 /* set SCP_SDCA_IntMask2[0]=1 */ 509 sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8); 510 dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__); 511 } else { 512 /* disable HID 1/2 event */ 513 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 514 RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0000); 515 516 dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__); 517 } 518 519 mutex_unlock(&rt711->calibrate_mutex); 520 } 521 522 static int rt711_sdca_set_jack_detect(struct snd_soc_component *component, 523 struct snd_soc_jack *hs_jack, void *data) 524 { 525 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 526 int ret; 527 528 rt711->hs_jack = hs_jack; 529 530 /* we can only resume if the device was initialized at least once */ 531 if (!rt711->first_hw_init) 532 return 0; 533 534 ret = pm_runtime_resume_and_get(component->dev); 535 if (ret < 0) { 536 if (ret != -EACCES) { 537 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret); 538 return ret; 539 } 540 541 /* pm_runtime not enabled yet */ 542 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__); 543 return 0; 544 } 545 546 rt711_sdca_jack_init(rt711); 547 548 pm_runtime_put_autosuspend(component->dev); 549 550 return 0; 551 } 552 553 /* For SDCA control DAC/ADC Gain */ 554 static int rt711_sdca_set_gain_put(struct snd_kcontrol *kcontrol, 555 struct snd_ctl_elem_value *ucontrol) 556 { 557 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 558 struct soc_mixer_control *mc = 559 (struct soc_mixer_control *)kcontrol->private_value; 560 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 561 unsigned int read_l, read_r, gain_l_val, gain_r_val; 562 unsigned int i, adc_vol_flag = 0, changed = 0; 563 unsigned int lvalue, rvalue; 564 565 if (strstr(ucontrol->id.name, "FU1E Capture Volume") || 566 strstr(ucontrol->id.name, "FU0F Capture Volume")) 567 adc_vol_flag = 1; 568 569 regmap_read(rt711->mbq_regmap, mc->reg, &lvalue); 570 regmap_read(rt711->mbq_regmap, mc->rreg, &rvalue); 571 572 /* control value to 2's complement value */ 573 /* L Channel */ 574 gain_l_val = ucontrol->value.integer.value[0]; 575 if (gain_l_val > mc->max) 576 gain_l_val = mc->max; 577 read_l = gain_l_val; 578 579 if (mc->shift == 8) /* boost gain */ 580 gain_l_val = (gain_l_val * 10) << mc->shift; 581 else { /* ADC/DAC gain */ 582 if (adc_vol_flag && gain_l_val > mc->shift) 583 gain_l_val = (gain_l_val - mc->shift) * 75; 584 else 585 gain_l_val = (mc->shift - gain_l_val) * 75; 586 gain_l_val <<= 8; 587 gain_l_val /= 100; 588 if (!(adc_vol_flag && read_l > mc->shift)) { 589 gain_l_val = ~gain_l_val; 590 gain_l_val += 1; 591 } 592 gain_l_val &= 0xffff; 593 } 594 595 /* R Channel */ 596 gain_r_val = ucontrol->value.integer.value[1]; 597 if (gain_r_val > mc->max) 598 gain_r_val = mc->max; 599 read_r = gain_r_val; 600 601 if (mc->shift == 8) /* boost gain */ 602 gain_r_val = (gain_r_val * 10) << mc->shift; 603 else { /* ADC/DAC gain */ 604 if (adc_vol_flag && gain_r_val > mc->shift) 605 gain_r_val = (gain_r_val - mc->shift) * 75; 606 else 607 gain_r_val = (mc->shift - gain_r_val) * 75; 608 gain_r_val <<= 8; 609 gain_r_val /= 100; 610 if (!(adc_vol_flag && read_r > mc->shift)) { 611 gain_r_val = ~gain_r_val; 612 gain_r_val += 1; 613 } 614 gain_r_val &= 0xffff; 615 } 616 617 if (lvalue != gain_l_val || rvalue != gain_r_val) 618 changed = 1; 619 else 620 return 0; 621 622 for (i = 0; i < 3; i++) { /* retry 3 times at most */ 623 /* Lch*/ 624 regmap_write(rt711->mbq_regmap, mc->reg, gain_l_val); 625 626 /* Rch */ 627 regmap_write(rt711->mbq_regmap, mc->rreg, gain_r_val); 628 629 regmap_read(rt711->mbq_regmap, mc->reg, &read_l); 630 regmap_read(rt711->mbq_regmap, mc->rreg, &read_r); 631 if (read_r == gain_r_val && read_l == gain_l_val) 632 break; 633 } 634 635 return i == 3 ? -EIO : changed; 636 } 637 638 static int rt711_sdca_set_gain_get(struct snd_kcontrol *kcontrol, 639 struct snd_ctl_elem_value *ucontrol) 640 { 641 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 642 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 643 struct soc_mixer_control *mc = 644 (struct soc_mixer_control *)kcontrol->private_value; 645 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0; 646 unsigned int adc_vol_flag = 0, neg_flag = 0; 647 648 if (strstr(ucontrol->id.name, "FU1E Capture Volume") || 649 strstr(ucontrol->id.name, "FU0F Capture Volume")) 650 adc_vol_flag = 1; 651 652 regmap_read(rt711->mbq_regmap, mc->reg, &read_l); 653 regmap_read(rt711->mbq_regmap, mc->rreg, &read_r); 654 655 /* 2's complement value to control value */ 656 if (mc->shift == 8) /* boost gain */ 657 ctl_l = (read_l >> mc->shift) / 10; 658 else { /* ADC/DAC gain */ 659 ctl_l = read_l; 660 if (read_l & BIT(15)) { 661 ctl_l = 0xffff & ~(read_l - 1); 662 neg_flag = 1; 663 } 664 ctl_l *= 100; 665 ctl_l >>= 8; 666 if (adc_vol_flag) { 667 if (neg_flag) 668 ctl_l = mc->shift - (ctl_l / 75); 669 else 670 ctl_l = mc->shift + (ctl_l / 75); 671 } else 672 ctl_l = mc->max - (ctl_l / 75); 673 } 674 675 neg_flag = 0; 676 if (read_l != read_r) { 677 if (mc->shift == 8) /* boost gain */ 678 ctl_r = (read_r >> mc->shift) / 10; 679 else { /* ADC/DAC gain */ 680 ctl_r = read_r; 681 if (read_r & BIT(15)) { 682 ctl_r = 0xffff & ~(read_r - 1); 683 neg_flag = 1; 684 } 685 ctl_r *= 100; 686 ctl_r >>= 8; 687 if (adc_vol_flag) { 688 if (neg_flag) 689 ctl_r = mc->shift - (ctl_r / 75); 690 else 691 ctl_r = mc->shift + (ctl_r / 75); 692 } else 693 ctl_r = mc->max - (ctl_r / 75); 694 } 695 } else 696 ctl_r = ctl_l; 697 698 ucontrol->value.integer.value[0] = ctl_l; 699 ucontrol->value.integer.value[1] = ctl_r; 700 701 return 0; 702 } 703 704 static int rt711_sdca_set_fu0f_capture_ctl(struct rt711_sdca_priv *rt711) 705 { 706 int err; 707 unsigned int ch_l, ch_r; 708 709 ch_l = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_l_mute) ? 0x01 : 0x00; 710 ch_r = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_r_mute) ? 0x01 : 0x00; 711 712 err = regmap_write(rt711->regmap, 713 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, 714 RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l); 715 if (err < 0) 716 return err; 717 718 err = regmap_write(rt711->regmap, 719 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, 720 RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r); 721 if (err < 0) 722 return err; 723 724 return 0; 725 } 726 727 static int rt711_sdca_set_fu1e_capture_ctl(struct rt711_sdca_priv *rt711) 728 { 729 int err; 730 unsigned int ch_l, ch_r; 731 732 ch_l = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_l_mute) ? 0x01 : 0x00; 733 ch_r = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_r_mute) ? 0x01 : 0x00; 734 735 err = regmap_write(rt711->regmap, 736 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, 737 RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l); 738 if (err < 0) 739 return err; 740 741 err = regmap_write(rt711->regmap, 742 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, 743 RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r); 744 if (err < 0) 745 return err; 746 747 return 0; 748 } 749 750 static int rt711_sdca_fu1e_capture_get(struct snd_kcontrol *kcontrol, 751 struct snd_ctl_elem_value *ucontrol) 752 { 753 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 754 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 755 756 ucontrol->value.integer.value[0] = !rt711->fu1e_mixer_l_mute; 757 ucontrol->value.integer.value[1] = !rt711->fu1e_mixer_r_mute; 758 return 0; 759 } 760 761 static int rt711_sdca_fu1e_capture_put(struct snd_kcontrol *kcontrol, 762 struct snd_ctl_elem_value *ucontrol) 763 { 764 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 765 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 766 int err, changed = 0; 767 768 if (rt711->fu1e_mixer_l_mute != !ucontrol->value.integer.value[0] || 769 rt711->fu1e_mixer_r_mute != !ucontrol->value.integer.value[1]) 770 changed = 1; 771 772 rt711->fu1e_mixer_l_mute = !ucontrol->value.integer.value[0]; 773 rt711->fu1e_mixer_r_mute = !ucontrol->value.integer.value[1]; 774 err = rt711_sdca_set_fu1e_capture_ctl(rt711); 775 if (err < 0) 776 return err; 777 778 return changed; 779 } 780 781 static int rt711_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol, 782 struct snd_ctl_elem_value *ucontrol) 783 { 784 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 785 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 786 787 ucontrol->value.integer.value[0] = !rt711->fu0f_mixer_l_mute; 788 ucontrol->value.integer.value[1] = !rt711->fu0f_mixer_r_mute; 789 return 0; 790 } 791 792 static int rt711_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol, 793 struct snd_ctl_elem_value *ucontrol) 794 { 795 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 796 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 797 int err, changed = 0; 798 799 if (rt711->fu0f_mixer_l_mute != !ucontrol->value.integer.value[0] || 800 rt711->fu0f_mixer_r_mute != !ucontrol->value.integer.value[1]) 801 changed = 1; 802 803 rt711->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0]; 804 rt711->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1]; 805 err = rt711_sdca_set_fu0f_capture_ctl(rt711); 806 if (err < 0) 807 return err; 808 809 return changed; 810 } 811 812 static int rt711_sdca_ge_select_get(struct snd_kcontrol *kcontrol, 813 struct snd_ctl_elem_value *ucontrol) 814 { 815 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 816 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 817 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 818 unsigned int val, item; 819 820 val = (rt711->ge_mode_override >> e->shift_l) & e->mask; 821 item = snd_soc_enum_val_to_item(e, val); 822 ucontrol->value.enumerated.item[0] = item; 823 return 0; 824 } 825 826 static int rt711_sdca_ge_select_put(struct snd_kcontrol *kcontrol, 827 struct snd_ctl_elem_value *ucontrol) 828 { 829 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 830 unsigned int *item = ucontrol->value.enumerated.item; 831 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 832 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 833 unsigned int val, change = 0; 834 835 if (item[0] >= e->items) 836 return -EINVAL; 837 838 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 839 if (rt711->ge_mode_override != val) { 840 rt711->ge_mode_override = val; 841 change = 1; 842 } 843 844 return change; 845 } 846 847 static const char * const rt711_sdca_ge_select[] = { 848 "Auto", 849 "Headphone", 850 "Headset", 851 }; 852 853 static int rt711_sdca_ge_select_values[] = { 854 0, 855 3, 856 5, 857 }; 858 859 static SOC_VALUE_ENUM_SINGLE_DECL(rt711_sdca_ge_mode_enum, SND_SOC_NOPM, 860 0, 0x7, rt711_sdca_ge_select, rt711_sdca_ge_select_values); 861 862 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0); 863 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0); 864 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0); 865 866 static const struct snd_kcontrol_new rt711_sdca_snd_controls[] = { 867 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume", 868 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_L), 869 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_R), 870 0x57, 0x57, 0, 871 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, out_vol_tlv), 872 SOC_DOUBLE_EXT("FU1E Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0, 873 rt711_sdca_fu1e_capture_get, rt711_sdca_fu1e_capture_put), 874 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0, 875 rt711_sdca_fu0f_capture_get, rt711_sdca_fu0f_capture_put), 876 SOC_DOUBLE_R_EXT_TLV("FU1E Capture Volume", 877 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_L), 878 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_R), 879 0x17, 0x3f, 0, 880 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv), 881 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume", 882 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_L), 883 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_R), 884 0x17, 0x3f, 0, 885 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv), 886 SOC_DOUBLE_R_EXT_TLV("FU44 Gain Volume", 887 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_L), 888 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_R), 889 8, 3, 0, 890 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv), 891 SOC_DOUBLE_R_EXT_TLV("FU15 Gain Volume", 892 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_L), 893 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_R), 894 8, 3, 0, 895 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv), 896 SOC_ENUM_EXT("GE49 Selected Mode", rt711_sdca_ge_mode_enum, 897 rt711_sdca_ge_select_get, rt711_sdca_ge_select_put), 898 }; 899 900 static int rt711_sdca_mux_get(struct snd_kcontrol *kcontrol, 901 struct snd_ctl_elem_value *ucontrol) 902 { 903 struct snd_soc_component *component = 904 snd_soc_dapm_kcontrol_component(kcontrol); 905 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 906 unsigned int val = 0, mask_sft; 907 908 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 909 mask_sft = 10; 910 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 911 mask_sft = 13; 912 else 913 return -EINVAL; 914 915 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL, 916 RT711_HDA_LEGACY_MUX_CTL1, &val); 917 918 ucontrol->value.enumerated.item[0] = (val >> mask_sft) & 0x7; 919 920 return 0; 921 } 922 923 static int rt711_sdca_mux_put(struct snd_kcontrol *kcontrol, 924 struct snd_ctl_elem_value *ucontrol) 925 { 926 struct snd_soc_component *component = 927 snd_soc_dapm_kcontrol_component(kcontrol); 928 struct snd_soc_dapm_context *dapm = 929 snd_soc_dapm_kcontrol_dapm(kcontrol); 930 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 931 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 932 unsigned int *item = ucontrol->value.enumerated.item; 933 unsigned int val, val2 = 0, change, mask_sft; 934 935 if (item[0] >= e->items) 936 return -EINVAL; 937 938 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 939 mask_sft = 10; 940 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 941 mask_sft = 13; 942 else 943 return -EINVAL; 944 945 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 946 947 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL, 948 RT711_HDA_LEGACY_MUX_CTL1, &val2); 949 val2 = (val2 >> mask_sft) & 0x7; 950 951 if (val == val2) 952 change = 0; 953 else 954 change = 1; 955 956 if (change) 957 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 958 RT711_HDA_LEGACY_MUX_CTL1, 0x7 << mask_sft, 959 val << mask_sft); 960 961 snd_soc_dapm_mux_update_power(dapm, kcontrol, 962 item[0], e, NULL); 963 964 return change; 965 } 966 967 static const char * const adc_mux_text[] = { 968 "MIC2", 969 "LINE1", 970 "LINE2", 971 "DMIC", 972 }; 973 974 static SOC_ENUM_SINGLE_DECL( 975 rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text); 976 977 static SOC_ENUM_SINGLE_DECL( 978 rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text); 979 980 static const struct snd_kcontrol_new rt711_sdca_adc22_mux = 981 SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum, 982 rt711_sdca_mux_get, rt711_sdca_mux_put); 983 984 static const struct snd_kcontrol_new rt711_sdca_adc23_mux = 985 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum, 986 rt711_sdca_mux_get, rt711_sdca_mux_put); 987 988 static int rt711_sdca_fu05_event(struct snd_soc_dapm_widget *w, 989 struct snd_kcontrol *kcontrol, int event) 990 { 991 struct snd_soc_component *component = 992 snd_soc_dapm_to_component(w->dapm); 993 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 994 unsigned char unmute = 0x0, mute = 0x1; 995 996 switch (event) { 997 case SND_SOC_DAPM_POST_PMU: 998 regmap_write(rt711->regmap, 999 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1000 RT711_SDCA_CTL_FU_MUTE, CH_L), 1001 unmute); 1002 regmap_write(rt711->regmap, 1003 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1004 RT711_SDCA_CTL_FU_MUTE, CH_R), 1005 unmute); 1006 break; 1007 case SND_SOC_DAPM_PRE_PMD: 1008 regmap_write(rt711->regmap, 1009 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1010 RT711_SDCA_CTL_FU_MUTE, CH_L), 1011 mute); 1012 regmap_write(rt711->regmap, 1013 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1014 RT711_SDCA_CTL_FU_MUTE, CH_R), 1015 mute); 1016 break; 1017 } 1018 return 0; 1019 } 1020 1021 static int rt711_sdca_fu0f_event(struct snd_soc_dapm_widget *w, 1022 struct snd_kcontrol *kcontrol, int event) 1023 { 1024 struct snd_soc_component *component = 1025 snd_soc_dapm_to_component(w->dapm); 1026 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1027 1028 switch (event) { 1029 case SND_SOC_DAPM_POST_PMU: 1030 rt711->fu0f_dapm_mute = false; 1031 rt711_sdca_set_fu0f_capture_ctl(rt711); 1032 break; 1033 case SND_SOC_DAPM_PRE_PMD: 1034 rt711->fu0f_dapm_mute = true; 1035 rt711_sdca_set_fu0f_capture_ctl(rt711); 1036 break; 1037 } 1038 return 0; 1039 } 1040 1041 static int rt711_sdca_fu1e_event(struct snd_soc_dapm_widget *w, 1042 struct snd_kcontrol *kcontrol, int event) 1043 { 1044 struct snd_soc_component *component = 1045 snd_soc_dapm_to_component(w->dapm); 1046 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1047 1048 switch (event) { 1049 case SND_SOC_DAPM_POST_PMU: 1050 rt711->fu1e_dapm_mute = false; 1051 rt711_sdca_set_fu1e_capture_ctl(rt711); 1052 break; 1053 case SND_SOC_DAPM_PRE_PMD: 1054 rt711->fu1e_dapm_mute = true; 1055 rt711_sdca_set_fu1e_capture_ctl(rt711); 1056 break; 1057 } 1058 return 0; 1059 } 1060 1061 static int rt711_sdca_pde28_event(struct snd_soc_dapm_widget *w, 1062 struct snd_kcontrol *kcontrol, int event) 1063 { 1064 struct snd_soc_component *component = 1065 snd_soc_dapm_to_component(w->dapm); 1066 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1067 unsigned char ps0 = 0x0, ps3 = 0x3; 1068 1069 switch (event) { 1070 case SND_SOC_DAPM_POST_PMU: 1071 regmap_write(rt711->regmap, 1072 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28, 1073 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1074 ps0); 1075 break; 1076 case SND_SOC_DAPM_PRE_PMD: 1077 regmap_write(rt711->regmap, 1078 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28, 1079 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1080 ps3); 1081 break; 1082 } 1083 return 0; 1084 } 1085 1086 static int rt711_sdca_pde29_event(struct snd_soc_dapm_widget *w, 1087 struct snd_kcontrol *kcontrol, int event) 1088 { 1089 struct snd_soc_component *component = 1090 snd_soc_dapm_to_component(w->dapm); 1091 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1092 unsigned char ps0 = 0x0, ps3 = 0x3; 1093 1094 switch (event) { 1095 case SND_SOC_DAPM_POST_PMU: 1096 regmap_write(rt711->regmap, 1097 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29, 1098 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1099 ps0); 1100 break; 1101 case SND_SOC_DAPM_PRE_PMD: 1102 regmap_write(rt711->regmap, 1103 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29, 1104 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1105 ps3); 1106 break; 1107 } 1108 return 0; 1109 } 1110 1111 static int rt711_sdca_pde2a_event(struct snd_soc_dapm_widget *w, 1112 struct snd_kcontrol *kcontrol, int event) 1113 { 1114 struct snd_soc_component *component = 1115 snd_soc_dapm_to_component(w->dapm); 1116 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1117 unsigned char ps0 = 0x0, ps3 = 0x3; 1118 1119 switch (event) { 1120 case SND_SOC_DAPM_POST_PMU: 1121 regmap_write(rt711->regmap, 1122 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A, 1123 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1124 ps0); 1125 break; 1126 case SND_SOC_DAPM_PRE_PMD: 1127 regmap_write(rt711->regmap, 1128 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A, 1129 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1130 ps3); 1131 break; 1132 } 1133 return 0; 1134 } 1135 1136 static int rt711_sdca_line1_power_event(struct snd_soc_dapm_widget *w, 1137 struct snd_kcontrol *kcontrol, int event) 1138 { 1139 struct snd_soc_component *component = 1140 snd_soc_dapm_to_component(w->dapm); 1141 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1142 static unsigned int sel_mode = 0xffff; 1143 1144 switch (event) { 1145 case SND_SOC_DAPM_POST_PMU: 1146 regmap_read(rt711->regmap, 1147 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1148 RT711_SDCA_CTL_SELECTED_MODE, 0), 1149 &sel_mode); 1150 regmap_write(rt711->regmap, 1151 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1, 1152 RT711_SDCA_CTL_VENDOR_DEF, 0), 1153 0x1); 1154 regmap_write(rt711->regmap, 1155 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1156 RT711_SDCA_CTL_SELECTED_MODE, 0), 1157 0x7); 1158 break; 1159 case SND_SOC_DAPM_PRE_PMD: 1160 regmap_write(rt711->regmap, 1161 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1, 1162 RT711_SDCA_CTL_VENDOR_DEF, 0), 1163 0x0); 1164 if (sel_mode != 0xffff) 1165 regmap_write(rt711->regmap, 1166 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1167 RT711_SDCA_CTL_SELECTED_MODE, 0), 1168 sel_mode); 1169 break; 1170 } 1171 1172 return 0; 1173 } 1174 1175 static int rt711_sdca_line2_power_event(struct snd_soc_dapm_widget *w, 1176 struct snd_kcontrol *kcontrol, int event) 1177 { 1178 struct snd_soc_component *component = 1179 snd_soc_dapm_to_component(w->dapm); 1180 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1181 unsigned char ps0 = 0x0, ps3 = 0x3; 1182 1183 switch (event) { 1184 case SND_SOC_DAPM_POST_PMU: 1185 regmap_write(rt711->regmap, 1186 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2, 1187 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1188 ps0); 1189 regmap_write(rt711->regmap, 1190 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2, 1191 RT711_SDCA_CTL_VENDOR_DEF, 0), 1192 0x1); 1193 break; 1194 case SND_SOC_DAPM_PRE_PMD: 1195 regmap_write(rt711->regmap, 1196 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2, 1197 RT711_SDCA_CTL_VENDOR_DEF, 0), 1198 0x0); 1199 regmap_write(rt711->regmap, 1200 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2, 1201 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1202 ps3); 1203 break; 1204 } 1205 1206 return 0; 1207 } 1208 1209 static const struct snd_soc_dapm_widget rt711_sdca_dapm_widgets[] = { 1210 SND_SOC_DAPM_OUTPUT("HP"), 1211 SND_SOC_DAPM_INPUT("MIC2"), 1212 SND_SOC_DAPM_INPUT("DMIC1"), 1213 SND_SOC_DAPM_INPUT("DMIC2"), 1214 SND_SOC_DAPM_INPUT("LINE1"), 1215 SND_SOC_DAPM_INPUT("LINE2"), 1216 1217 SND_SOC_DAPM_PGA_E("LINE1 Power", SND_SOC_NOPM, 1218 0, 0, NULL, 0, rt711_sdca_line1_power_event, 1219 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1220 SND_SOC_DAPM_PGA_E("LINE2 Power", SND_SOC_NOPM, 1221 0, 0, NULL, 0, rt711_sdca_line2_power_event, 1222 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1223 1224 SND_SOC_DAPM_SUPPLY("PDE 28", SND_SOC_NOPM, 0, 0, 1225 rt711_sdca_pde28_event, 1226 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1227 SND_SOC_DAPM_SUPPLY("PDE 29", SND_SOC_NOPM, 0, 0, 1228 rt711_sdca_pde29_event, 1229 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1230 SND_SOC_DAPM_SUPPLY("PDE 2A", SND_SOC_NOPM, 0, 0, 1231 rt711_sdca_pde2a_event, 1232 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1233 1234 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0, 1235 rt711_sdca_fu05_event, 1236 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1237 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0, 1238 rt711_sdca_fu0f_event, 1239 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1240 SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0, 1241 rt711_sdca_fu1e_event, 1242 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1243 SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0, 1244 &rt711_sdca_adc22_mux), 1245 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0, 1246 &rt711_sdca_adc23_mux), 1247 1248 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 1249 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0), 1250 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0), 1251 }; 1252 1253 static const struct snd_soc_dapm_route rt711_sdca_audio_map[] = { 1254 {"FU 05", NULL, "DP3RX"}, 1255 {"DP2TX", NULL, "FU 0F"}, 1256 {"DP4TX", NULL, "FU 1E"}, 1257 1258 {"LINE1 Power", NULL, "LINE1"}, 1259 {"LINE2 Power", NULL, "LINE2"}, 1260 {"HP", NULL, "PDE 28"}, 1261 {"FU 0F", NULL, "PDE 29"}, 1262 {"FU 1E", NULL, "PDE 2A"}, 1263 1264 {"FU 0F", NULL, "ADC 22 Mux"}, 1265 {"FU 1E", NULL, "ADC 23 Mux"}, 1266 {"ADC 22 Mux", "DMIC", "DMIC1"}, 1267 {"ADC 22 Mux", "LINE1", "LINE1 Power"}, 1268 {"ADC 22 Mux", "LINE2", "LINE2 Power"}, 1269 {"ADC 22 Mux", "MIC2", "MIC2"}, 1270 {"ADC 23 Mux", "DMIC", "DMIC2"}, 1271 {"ADC 23 Mux", "LINE1", "LINE1 Power"}, 1272 {"ADC 23 Mux", "LINE2", "LINE2 Power"}, 1273 {"ADC 23 Mux", "MIC2", "MIC2"}, 1274 1275 {"HP", NULL, "FU 05"}, 1276 }; 1277 1278 static int rt711_sdca_parse_dt(struct rt711_sdca_priv *rt711, struct device *dev) 1279 { 1280 device_property_read_u32(dev, "realtek,jd-src", &rt711->jd_src); 1281 1282 return 0; 1283 } 1284 1285 static int rt711_sdca_probe(struct snd_soc_component *component) 1286 { 1287 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1288 int ret; 1289 1290 rt711_sdca_parse_dt(rt711, &rt711->slave->dev); 1291 rt711->component = component; 1292 1293 if (!rt711->first_hw_init) 1294 return 0; 1295 1296 ret = pm_runtime_resume(component->dev); 1297 if (ret < 0 && ret != -EACCES) 1298 return ret; 1299 1300 return 0; 1301 } 1302 1303 static const struct snd_soc_component_driver soc_sdca_dev_rt711 = { 1304 .probe = rt711_sdca_probe, 1305 .controls = rt711_sdca_snd_controls, 1306 .num_controls = ARRAY_SIZE(rt711_sdca_snd_controls), 1307 .dapm_widgets = rt711_sdca_dapm_widgets, 1308 .num_dapm_widgets = ARRAY_SIZE(rt711_sdca_dapm_widgets), 1309 .dapm_routes = rt711_sdca_audio_map, 1310 .num_dapm_routes = ARRAY_SIZE(rt711_sdca_audio_map), 1311 .set_jack = rt711_sdca_set_jack_detect, 1312 .endianness = 1, 1313 }; 1314 1315 static int rt711_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 1316 int direction) 1317 { 1318 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 1319 1320 return 0; 1321 } 1322 1323 static void rt711_sdca_shutdown(struct snd_pcm_substream *substream, 1324 struct snd_soc_dai *dai) 1325 { 1326 snd_soc_dai_set_dma_data(dai, substream, NULL); 1327 } 1328 1329 static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream, 1330 struct snd_pcm_hw_params *params, 1331 struct snd_soc_dai *dai) 1332 { 1333 struct snd_soc_component *component = dai->component; 1334 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1335 struct sdw_stream_config stream_config = {0}; 1336 struct sdw_port_config port_config = {0}; 1337 struct sdw_stream_runtime *sdw_stream; 1338 int retval; 1339 unsigned int sampling_rate; 1340 1341 dev_dbg(dai->dev, "%s %s", __func__, dai->name); 1342 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 1343 1344 if (!sdw_stream) 1345 return -EINVAL; 1346 1347 if (!rt711->slave) 1348 return -EINVAL; 1349 1350 /* SoundWire specific configuration */ 1351 snd_sdw_params_to_config(substream, params, &stream_config, &port_config); 1352 1353 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1354 port_config.num = 3; 1355 } else { 1356 if (dai->id == RT711_AIF1) 1357 port_config.num = 2; 1358 else if (dai->id == RT711_AIF2) 1359 port_config.num = 4; 1360 else 1361 return -EINVAL; 1362 } 1363 1364 retval = sdw_stream_add_slave(rt711->slave, &stream_config, 1365 &port_config, 1, sdw_stream); 1366 if (retval) { 1367 dev_err(dai->dev, "%s: Unable to configure port\n", __func__); 1368 return retval; 1369 } 1370 1371 if (params_channels(params) > 16) { 1372 dev_err(component->dev, "%s: Unsupported channels %d\n", 1373 __func__, params_channels(params)); 1374 return -EINVAL; 1375 } 1376 1377 /* sampling rate configuration */ 1378 switch (params_rate(params)) { 1379 case 44100: 1380 sampling_rate = RT711_SDCA_RATE_44100HZ; 1381 break; 1382 case 48000: 1383 sampling_rate = RT711_SDCA_RATE_48000HZ; 1384 break; 1385 case 96000: 1386 sampling_rate = RT711_SDCA_RATE_96000HZ; 1387 break; 1388 case 192000: 1389 sampling_rate = RT711_SDCA_RATE_192000HZ; 1390 break; 1391 default: 1392 dev_err(component->dev, "%s: Rate %d is not supported\n", 1393 __func__, params_rate(params)); 1394 return -EINVAL; 1395 } 1396 1397 /* set sampling frequency */ 1398 regmap_write(rt711->regmap, 1399 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS01, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1400 sampling_rate); 1401 regmap_write(rt711->regmap, 1402 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS11, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1403 sampling_rate); 1404 regmap_write(rt711->regmap, 1405 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_CS1F, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1406 sampling_rate); 1407 1408 return 0; 1409 } 1410 1411 static int rt711_sdca_pcm_hw_free(struct snd_pcm_substream *substream, 1412 struct snd_soc_dai *dai) 1413 { 1414 struct snd_soc_component *component = dai->component; 1415 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1416 struct sdw_stream_runtime *sdw_stream = 1417 snd_soc_dai_get_dma_data(dai, substream); 1418 1419 if (!rt711->slave) 1420 return -EINVAL; 1421 1422 sdw_stream_remove_slave(rt711->slave, sdw_stream); 1423 return 0; 1424 } 1425 1426 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ 1427 SNDRV_PCM_RATE_192000) 1428 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \ 1429 SNDRV_PCM_FMTBIT_S24_LE) 1430 1431 static const struct snd_soc_dai_ops rt711_sdca_ops = { 1432 .hw_params = rt711_sdca_pcm_hw_params, 1433 .hw_free = rt711_sdca_pcm_hw_free, 1434 .set_stream = rt711_sdca_set_sdw_stream, 1435 .shutdown = rt711_sdca_shutdown, 1436 }; 1437 1438 static struct snd_soc_dai_driver rt711_sdca_dai[] = { 1439 { 1440 .name = "rt711-sdca-aif1", 1441 .id = RT711_AIF1, 1442 .playback = { 1443 .stream_name = "DP3 Playback", 1444 .channels_min = 1, 1445 .channels_max = 2, 1446 .rates = RT711_STEREO_RATES, 1447 .formats = RT711_FORMATS, 1448 }, 1449 .capture = { 1450 .stream_name = "DP2 Capture", 1451 .channels_min = 1, 1452 .channels_max = 2, 1453 .rates = RT711_STEREO_RATES, 1454 .formats = RT711_FORMATS, 1455 }, 1456 .ops = &rt711_sdca_ops, 1457 }, 1458 { 1459 .name = "rt711-sdca-aif2", 1460 .id = RT711_AIF2, 1461 .capture = { 1462 .stream_name = "DP4 Capture", 1463 .channels_min = 1, 1464 .channels_max = 2, 1465 .rates = RT711_STEREO_RATES, 1466 .formats = RT711_FORMATS, 1467 }, 1468 .ops = &rt711_sdca_ops, 1469 } 1470 }; 1471 1472 int rt711_sdca_init(struct device *dev, struct regmap *regmap, 1473 struct regmap *mbq_regmap, struct sdw_slave *slave) 1474 { 1475 struct rt711_sdca_priv *rt711; 1476 int ret; 1477 1478 rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL); 1479 if (!rt711) 1480 return -ENOMEM; 1481 1482 dev_set_drvdata(dev, rt711); 1483 rt711->slave = slave; 1484 rt711->regmap = regmap; 1485 rt711->mbq_regmap = mbq_regmap; 1486 1487 regcache_cache_only(rt711->regmap, true); 1488 regcache_cache_only(rt711->mbq_regmap, true); 1489 1490 mutex_init(&rt711->calibrate_mutex); 1491 mutex_init(&rt711->disable_irq_lock); 1492 1493 INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_sdca_jack_detect_handler); 1494 INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_sdca_btn_check_handler); 1495 1496 /* 1497 * Mark hw_init to false 1498 * HW init will be performed when device reports present 1499 */ 1500 rt711->hw_init = false; 1501 rt711->first_hw_init = false; 1502 rt711->fu0f_dapm_mute = true; 1503 rt711->fu1e_dapm_mute = true; 1504 rt711->fu0f_mixer_l_mute = rt711->fu0f_mixer_r_mute = true; 1505 rt711->fu1e_mixer_l_mute = rt711->fu1e_mixer_r_mute = true; 1506 1507 /* JD source uses JD2 in default */ 1508 rt711->jd_src = RT711_JD2; 1509 1510 ret = devm_snd_soc_register_component(dev, 1511 &soc_sdca_dev_rt711, 1512 rt711_sdca_dai, 1513 ARRAY_SIZE(rt711_sdca_dai)); 1514 1515 if (ret < 0) 1516 return ret; 1517 1518 /* set autosuspend parameters */ 1519 pm_runtime_set_autosuspend_delay(dev, 3000); 1520 pm_runtime_use_autosuspend(dev); 1521 1522 /* make sure the device does not suspend immediately */ 1523 pm_runtime_mark_last_busy(dev); 1524 1525 pm_runtime_enable(dev); 1526 1527 /* important note: the device is NOT tagged as 'active' and will remain 1528 * 'suspended' until the hardware is enumerated/initialized. This is required 1529 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently 1530 * fail with -EACCESS because of race conditions between card creation and enumeration 1531 */ 1532 1533 dev_dbg(dev, "%s\n", __func__); 1534 1535 return 0; 1536 } 1537 1538 static void rt711_sdca_vd0_io_init(struct rt711_sdca_priv *rt711) 1539 { 1540 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1541 RT711_GPIO_TEST_MODE_CTL2, 0x0e00); 1542 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1543 RT711_HDA_LEGACY_GPIO_CTL, 0x0008); 1544 1545 regmap_write(rt711->regmap, 0x2f5a, 0x01); 1546 1547 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1548 RT711_ADC27_VOL_SET, 0x8728); 1549 1550 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1551 RT711_COMBO_JACK_AUTO_CTL3, 0xa472); 1552 1553 regmap_write(rt711->regmap, 0x2f50, 0x02); 1554 1555 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL, 1556 RT711_MISC_POWER_CTL4, 0x6000, 0x6000); 1557 1558 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 1559 RT711_COMBO_JACK_AUTO_CTL3, 0x000c, 0x000c); 1560 1561 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1562 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000); 1563 1564 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD, 1565 RT711_VAD_SRAM_CTL1, 0x0050); 1566 } 1567 1568 static void rt711_sdca_vd1_io_init(struct rt711_sdca_priv *rt711) 1569 { 1570 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 1571 RT711_HDA_LEGACY_UNSOLICITED_CTL, 0x0300, 0x0000); 1572 1573 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1574 RT711_COMBO_JACK_AUTO_CTL3, 0xa43e); 1575 1576 regmap_write(rt711->regmap, 0x2f5a, 0x05); 1577 1578 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1579 RT711_JD_CTRL6, 0x0500); 1580 1581 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1582 RT711_DMIC_CTL1, 0x6173); 1583 1584 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1585 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000); 1586 1587 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD, 1588 RT711_VAD_SRAM_CTL1, 0x0050); 1589 } 1590 1591 int rt711_sdca_io_init(struct device *dev, struct sdw_slave *slave) 1592 { 1593 struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev); 1594 int ret = 0; 1595 unsigned int val; 1596 1597 rt711->disable_irq = false; 1598 1599 if (rt711->hw_init) 1600 return 0; 1601 1602 regcache_cache_only(rt711->regmap, false); 1603 regcache_cache_only(rt711->mbq_regmap, false); 1604 1605 if (rt711->first_hw_init) { 1606 regcache_cache_bypass(rt711->regmap, true); 1607 regcache_cache_bypass(rt711->mbq_regmap, true); 1608 } else { 1609 /* 1610 * PM runtime status is marked as 'active' only when a Slave reports as Attached 1611 */ 1612 1613 /* update count of parent 'active' children */ 1614 pm_runtime_set_active(&slave->dev); 1615 } 1616 1617 pm_runtime_get_noresume(&slave->dev); 1618 1619 rt711_sdca_reset(rt711); 1620 1621 rt711_sdca_index_read(rt711, RT711_VENDOR_REG, RT711_JD_PRODUCT_NUM, &val); 1622 rt711->hw_ver = val & 0xf; 1623 1624 if (rt711->hw_ver == RT711_VER_VD0) 1625 rt711_sdca_vd0_io_init(rt711); 1626 else 1627 rt711_sdca_vd1_io_init(rt711); 1628 1629 /* DP4 mux select from 08_filter_Out_pri */ 1630 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 1631 RT711_FILTER_SRC_SEL, 0x1800, 0x0800); 1632 1633 /* ge_exclusive_inbox_en disable */ 1634 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 1635 RT711_PUSH_BTN_INT_CTL0, 0x20, 0x00); 1636 1637 /* calibration */ 1638 ret = rt711_sdca_calibration(rt711); 1639 if (ret < 0) 1640 dev_err(dev, "%s, calibration failed!\n", __func__); 1641 1642 /* HP output enable */ 1643 regmap_write(rt711->regmap, 1644 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_OT1, RT711_SDCA_CTL_VENDOR_DEF, 0), 0x4); 1645 1646 /* 1647 * if set_jack callback occurred early than io_init, 1648 * we set up the jack detection function now 1649 */ 1650 if (rt711->hs_jack) 1651 rt711_sdca_jack_init(rt711); 1652 1653 if (rt711->first_hw_init) { 1654 regcache_cache_bypass(rt711->regmap, false); 1655 regcache_mark_dirty(rt711->regmap); 1656 regcache_cache_bypass(rt711->mbq_regmap, false); 1657 regcache_mark_dirty(rt711->mbq_regmap); 1658 } else 1659 rt711->first_hw_init = true; 1660 1661 /* Mark Slave initialization complete */ 1662 rt711->hw_init = true; 1663 1664 pm_runtime_put_autosuspend(&slave->dev); 1665 1666 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1667 return 0; 1668 } 1669 1670 MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver"); 1671 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1672 MODULE_LICENSE("GPL"); 1673