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_kcontrol_chip(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_kcontrol_chip(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 = snd_soc_dapm_kcontrol_to_component(kcontrol); 904 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 905 unsigned int val = 0, mask_sft; 906 907 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 908 mask_sft = 10; 909 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 910 mask_sft = 13; 911 else 912 return -EINVAL; 913 914 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL, 915 RT711_HDA_LEGACY_MUX_CTL1, &val); 916 917 ucontrol->value.enumerated.item[0] = (val >> mask_sft) & 0x7; 918 919 return 0; 920 } 921 922 static int rt711_sdca_mux_put(struct snd_kcontrol *kcontrol, 923 struct snd_ctl_elem_value *ucontrol) 924 { 925 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol); 926 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol); 927 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 928 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 929 unsigned int *item = ucontrol->value.enumerated.item; 930 unsigned int val, val2 = 0, change, mask_sft; 931 932 if (item[0] >= e->items) 933 return -EINVAL; 934 935 if (strstr(ucontrol->id.name, "ADC 22 Mux")) 936 mask_sft = 10; 937 else if (strstr(ucontrol->id.name, "ADC 23 Mux")) 938 mask_sft = 13; 939 else 940 return -EINVAL; 941 942 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 943 944 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL, 945 RT711_HDA_LEGACY_MUX_CTL1, &val2); 946 val2 = (val2 >> mask_sft) & 0x7; 947 948 if (val == val2) 949 change = 0; 950 else 951 change = 1; 952 953 if (change) 954 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 955 RT711_HDA_LEGACY_MUX_CTL1, 0x7 << mask_sft, 956 val << mask_sft); 957 958 snd_soc_dapm_mux_update_power(dapm, kcontrol, 959 item[0], e, NULL); 960 961 return change; 962 } 963 964 static const char * const adc_mux_text[] = { 965 "MIC2", 966 "LINE1", 967 "LINE2", 968 "DMIC", 969 }; 970 971 static SOC_ENUM_SINGLE_DECL( 972 rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text); 973 974 static SOC_ENUM_SINGLE_DECL( 975 rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text); 976 977 static const struct snd_kcontrol_new rt711_sdca_adc22_mux = 978 SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum, 979 rt711_sdca_mux_get, rt711_sdca_mux_put); 980 981 static const struct snd_kcontrol_new rt711_sdca_adc23_mux = 982 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum, 983 rt711_sdca_mux_get, rt711_sdca_mux_put); 984 985 static int rt711_sdca_fu05_event(struct snd_soc_dapm_widget *w, 986 struct snd_kcontrol *kcontrol, int event) 987 { 988 struct snd_soc_component *component = 989 snd_soc_dapm_to_component(w->dapm); 990 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 991 unsigned char unmute = 0x0, mute = 0x1; 992 993 switch (event) { 994 case SND_SOC_DAPM_POST_PMU: 995 regmap_write(rt711->regmap, 996 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 997 RT711_SDCA_CTL_FU_MUTE, CH_L), 998 unmute); 999 regmap_write(rt711->regmap, 1000 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1001 RT711_SDCA_CTL_FU_MUTE, CH_R), 1002 unmute); 1003 break; 1004 case SND_SOC_DAPM_PRE_PMD: 1005 regmap_write(rt711->regmap, 1006 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1007 RT711_SDCA_CTL_FU_MUTE, CH_L), 1008 mute); 1009 regmap_write(rt711->regmap, 1010 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, 1011 RT711_SDCA_CTL_FU_MUTE, CH_R), 1012 mute); 1013 break; 1014 } 1015 return 0; 1016 } 1017 1018 static int rt711_sdca_fu0f_event(struct snd_soc_dapm_widget *w, 1019 struct snd_kcontrol *kcontrol, int event) 1020 { 1021 struct snd_soc_component *component = 1022 snd_soc_dapm_to_component(w->dapm); 1023 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1024 1025 switch (event) { 1026 case SND_SOC_DAPM_POST_PMU: 1027 rt711->fu0f_dapm_mute = false; 1028 rt711_sdca_set_fu0f_capture_ctl(rt711); 1029 break; 1030 case SND_SOC_DAPM_PRE_PMD: 1031 rt711->fu0f_dapm_mute = true; 1032 rt711_sdca_set_fu0f_capture_ctl(rt711); 1033 break; 1034 } 1035 return 0; 1036 } 1037 1038 static int rt711_sdca_fu1e_event(struct snd_soc_dapm_widget *w, 1039 struct snd_kcontrol *kcontrol, int event) 1040 { 1041 struct snd_soc_component *component = 1042 snd_soc_dapm_to_component(w->dapm); 1043 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1044 1045 switch (event) { 1046 case SND_SOC_DAPM_POST_PMU: 1047 rt711->fu1e_dapm_mute = false; 1048 rt711_sdca_set_fu1e_capture_ctl(rt711); 1049 break; 1050 case SND_SOC_DAPM_PRE_PMD: 1051 rt711->fu1e_dapm_mute = true; 1052 rt711_sdca_set_fu1e_capture_ctl(rt711); 1053 break; 1054 } 1055 return 0; 1056 } 1057 1058 static int rt711_sdca_pde28_event(struct snd_soc_dapm_widget *w, 1059 struct snd_kcontrol *kcontrol, int event) 1060 { 1061 struct snd_soc_component *component = 1062 snd_soc_dapm_to_component(w->dapm); 1063 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1064 unsigned char ps0 = 0x0, ps3 = 0x3; 1065 1066 switch (event) { 1067 case SND_SOC_DAPM_POST_PMU: 1068 regmap_write(rt711->regmap, 1069 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28, 1070 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1071 ps0); 1072 break; 1073 case SND_SOC_DAPM_PRE_PMD: 1074 regmap_write(rt711->regmap, 1075 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28, 1076 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1077 ps3); 1078 break; 1079 } 1080 return 0; 1081 } 1082 1083 static int rt711_sdca_pde29_event(struct snd_soc_dapm_widget *w, 1084 struct snd_kcontrol *kcontrol, int event) 1085 { 1086 struct snd_soc_component *component = 1087 snd_soc_dapm_to_component(w->dapm); 1088 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1089 unsigned char ps0 = 0x0, ps3 = 0x3; 1090 1091 switch (event) { 1092 case SND_SOC_DAPM_POST_PMU: 1093 regmap_write(rt711->regmap, 1094 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29, 1095 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1096 ps0); 1097 break; 1098 case SND_SOC_DAPM_PRE_PMD: 1099 regmap_write(rt711->regmap, 1100 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29, 1101 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1102 ps3); 1103 break; 1104 } 1105 return 0; 1106 } 1107 1108 static int rt711_sdca_pde2a_event(struct snd_soc_dapm_widget *w, 1109 struct snd_kcontrol *kcontrol, int event) 1110 { 1111 struct snd_soc_component *component = 1112 snd_soc_dapm_to_component(w->dapm); 1113 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1114 unsigned char ps0 = 0x0, ps3 = 0x3; 1115 1116 switch (event) { 1117 case SND_SOC_DAPM_POST_PMU: 1118 regmap_write(rt711->regmap, 1119 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A, 1120 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1121 ps0); 1122 break; 1123 case SND_SOC_DAPM_PRE_PMD: 1124 regmap_write(rt711->regmap, 1125 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A, 1126 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1127 ps3); 1128 break; 1129 } 1130 return 0; 1131 } 1132 1133 static int rt711_sdca_line1_power_event(struct snd_soc_dapm_widget *w, 1134 struct snd_kcontrol *kcontrol, int event) 1135 { 1136 struct snd_soc_component *component = 1137 snd_soc_dapm_to_component(w->dapm); 1138 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1139 static unsigned int sel_mode = 0xffff; 1140 1141 switch (event) { 1142 case SND_SOC_DAPM_POST_PMU: 1143 regmap_read(rt711->regmap, 1144 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1145 RT711_SDCA_CTL_SELECTED_MODE, 0), 1146 &sel_mode); 1147 regmap_write(rt711->regmap, 1148 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1, 1149 RT711_SDCA_CTL_VENDOR_DEF, 0), 1150 0x1); 1151 regmap_write(rt711->regmap, 1152 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1153 RT711_SDCA_CTL_SELECTED_MODE, 0), 1154 0x7); 1155 break; 1156 case SND_SOC_DAPM_PRE_PMD: 1157 regmap_write(rt711->regmap, 1158 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1, 1159 RT711_SDCA_CTL_VENDOR_DEF, 0), 1160 0x0); 1161 if (sel_mode != 0xffff) 1162 regmap_write(rt711->regmap, 1163 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, 1164 RT711_SDCA_CTL_SELECTED_MODE, 0), 1165 sel_mode); 1166 break; 1167 } 1168 1169 return 0; 1170 } 1171 1172 static int rt711_sdca_line2_power_event(struct snd_soc_dapm_widget *w, 1173 struct snd_kcontrol *kcontrol, int event) 1174 { 1175 struct snd_soc_component *component = 1176 snd_soc_dapm_to_component(w->dapm); 1177 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1178 unsigned char ps0 = 0x0, ps3 = 0x3; 1179 1180 switch (event) { 1181 case SND_SOC_DAPM_POST_PMU: 1182 regmap_write(rt711->regmap, 1183 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2, 1184 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1185 ps0); 1186 regmap_write(rt711->regmap, 1187 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2, 1188 RT711_SDCA_CTL_VENDOR_DEF, 0), 1189 0x1); 1190 break; 1191 case SND_SOC_DAPM_PRE_PMD: 1192 regmap_write(rt711->regmap, 1193 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2, 1194 RT711_SDCA_CTL_VENDOR_DEF, 0), 1195 0x0); 1196 regmap_write(rt711->regmap, 1197 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2, 1198 RT711_SDCA_CTL_REQ_POWER_STATE, 0), 1199 ps3); 1200 break; 1201 } 1202 1203 return 0; 1204 } 1205 1206 static const struct snd_soc_dapm_widget rt711_sdca_dapm_widgets[] = { 1207 SND_SOC_DAPM_OUTPUT("HP"), 1208 SND_SOC_DAPM_INPUT("MIC2"), 1209 SND_SOC_DAPM_INPUT("DMIC1"), 1210 SND_SOC_DAPM_INPUT("DMIC2"), 1211 SND_SOC_DAPM_INPUT("LINE1"), 1212 SND_SOC_DAPM_INPUT("LINE2"), 1213 1214 SND_SOC_DAPM_PGA_E("LINE1 Power", SND_SOC_NOPM, 1215 0, 0, NULL, 0, rt711_sdca_line1_power_event, 1216 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1217 SND_SOC_DAPM_PGA_E("LINE2 Power", SND_SOC_NOPM, 1218 0, 0, NULL, 0, rt711_sdca_line2_power_event, 1219 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1220 1221 SND_SOC_DAPM_SUPPLY("PDE 28", SND_SOC_NOPM, 0, 0, 1222 rt711_sdca_pde28_event, 1223 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1224 SND_SOC_DAPM_SUPPLY("PDE 29", SND_SOC_NOPM, 0, 0, 1225 rt711_sdca_pde29_event, 1226 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1227 SND_SOC_DAPM_SUPPLY("PDE 2A", SND_SOC_NOPM, 0, 0, 1228 rt711_sdca_pde2a_event, 1229 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1230 1231 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0, 1232 rt711_sdca_fu05_event, 1233 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1234 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0, 1235 rt711_sdca_fu0f_event, 1236 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1237 SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0, 1238 rt711_sdca_fu1e_event, 1239 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1240 SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0, 1241 &rt711_sdca_adc22_mux), 1242 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0, 1243 &rt711_sdca_adc23_mux), 1244 1245 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 1246 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0), 1247 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0), 1248 }; 1249 1250 static const struct snd_soc_dapm_route rt711_sdca_audio_map[] = { 1251 {"FU 05", NULL, "DP3RX"}, 1252 {"DP2TX", NULL, "FU 0F"}, 1253 {"DP4TX", NULL, "FU 1E"}, 1254 1255 {"LINE1 Power", NULL, "LINE1"}, 1256 {"LINE2 Power", NULL, "LINE2"}, 1257 {"HP", NULL, "PDE 28"}, 1258 {"FU 0F", NULL, "PDE 29"}, 1259 {"FU 1E", NULL, "PDE 2A"}, 1260 1261 {"FU 0F", NULL, "ADC 22 Mux"}, 1262 {"FU 1E", NULL, "ADC 23 Mux"}, 1263 {"ADC 22 Mux", "DMIC", "DMIC1"}, 1264 {"ADC 22 Mux", "LINE1", "LINE1 Power"}, 1265 {"ADC 22 Mux", "LINE2", "LINE2 Power"}, 1266 {"ADC 22 Mux", "MIC2", "MIC2"}, 1267 {"ADC 23 Mux", "DMIC", "DMIC2"}, 1268 {"ADC 23 Mux", "LINE1", "LINE1 Power"}, 1269 {"ADC 23 Mux", "LINE2", "LINE2 Power"}, 1270 {"ADC 23 Mux", "MIC2", "MIC2"}, 1271 1272 {"HP", NULL, "FU 05"}, 1273 }; 1274 1275 static int rt711_sdca_parse_dt(struct rt711_sdca_priv *rt711, struct device *dev) 1276 { 1277 device_property_read_u32(dev, "realtek,jd-src", &rt711->jd_src); 1278 1279 return 0; 1280 } 1281 1282 static int rt711_sdca_probe(struct snd_soc_component *component) 1283 { 1284 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1285 int ret; 1286 1287 rt711_sdca_parse_dt(rt711, &rt711->slave->dev); 1288 rt711->component = component; 1289 1290 if (!rt711->first_hw_init) 1291 return 0; 1292 1293 ret = pm_runtime_resume(component->dev); 1294 if (ret < 0 && ret != -EACCES) 1295 return ret; 1296 1297 return 0; 1298 } 1299 1300 static const struct snd_soc_component_driver soc_sdca_dev_rt711 = { 1301 .probe = rt711_sdca_probe, 1302 .controls = rt711_sdca_snd_controls, 1303 .num_controls = ARRAY_SIZE(rt711_sdca_snd_controls), 1304 .dapm_widgets = rt711_sdca_dapm_widgets, 1305 .num_dapm_widgets = ARRAY_SIZE(rt711_sdca_dapm_widgets), 1306 .dapm_routes = rt711_sdca_audio_map, 1307 .num_dapm_routes = ARRAY_SIZE(rt711_sdca_audio_map), 1308 .set_jack = rt711_sdca_set_jack_detect, 1309 .endianness = 1, 1310 }; 1311 1312 static int rt711_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 1313 int direction) 1314 { 1315 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 1316 1317 return 0; 1318 } 1319 1320 static void rt711_sdca_shutdown(struct snd_pcm_substream *substream, 1321 struct snd_soc_dai *dai) 1322 { 1323 snd_soc_dai_set_dma_data(dai, substream, NULL); 1324 } 1325 1326 static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream, 1327 struct snd_pcm_hw_params *params, 1328 struct snd_soc_dai *dai) 1329 { 1330 struct snd_soc_component *component = dai->component; 1331 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1332 struct sdw_stream_config stream_config = {0}; 1333 struct sdw_port_config port_config = {0}; 1334 struct sdw_stream_runtime *sdw_stream; 1335 int retval; 1336 unsigned int sampling_rate; 1337 1338 dev_dbg(dai->dev, "%s %s", __func__, dai->name); 1339 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 1340 1341 if (!sdw_stream) 1342 return -EINVAL; 1343 1344 if (!rt711->slave) 1345 return -EINVAL; 1346 1347 /* SoundWire specific configuration */ 1348 snd_sdw_params_to_config(substream, params, &stream_config, &port_config); 1349 1350 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1351 port_config.num = 3; 1352 } else { 1353 if (dai->id == RT711_AIF1) 1354 port_config.num = 2; 1355 else if (dai->id == RT711_AIF2) 1356 port_config.num = 4; 1357 else 1358 return -EINVAL; 1359 } 1360 1361 retval = sdw_stream_add_slave(rt711->slave, &stream_config, 1362 &port_config, 1, sdw_stream); 1363 if (retval) { 1364 dev_err(dai->dev, "%s: Unable to configure port\n", __func__); 1365 return retval; 1366 } 1367 1368 if (params_channels(params) > 16) { 1369 dev_err(component->dev, "%s: Unsupported channels %d\n", 1370 __func__, params_channels(params)); 1371 return -EINVAL; 1372 } 1373 1374 /* sampling rate configuration */ 1375 switch (params_rate(params)) { 1376 case 44100: 1377 sampling_rate = RT711_SDCA_RATE_44100HZ; 1378 break; 1379 case 48000: 1380 sampling_rate = RT711_SDCA_RATE_48000HZ; 1381 break; 1382 case 96000: 1383 sampling_rate = RT711_SDCA_RATE_96000HZ; 1384 break; 1385 case 192000: 1386 sampling_rate = RT711_SDCA_RATE_192000HZ; 1387 break; 1388 default: 1389 dev_err(component->dev, "%s: Rate %d is not supported\n", 1390 __func__, params_rate(params)); 1391 return -EINVAL; 1392 } 1393 1394 /* set sampling frequency */ 1395 regmap_write(rt711->regmap, 1396 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS01, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1397 sampling_rate); 1398 regmap_write(rt711->regmap, 1399 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS11, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1400 sampling_rate); 1401 regmap_write(rt711->regmap, 1402 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_CS1F, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1403 sampling_rate); 1404 1405 return 0; 1406 } 1407 1408 static int rt711_sdca_pcm_hw_free(struct snd_pcm_substream *substream, 1409 struct snd_soc_dai *dai) 1410 { 1411 struct snd_soc_component *component = dai->component; 1412 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component); 1413 struct sdw_stream_runtime *sdw_stream = 1414 snd_soc_dai_get_dma_data(dai, substream); 1415 1416 if (!rt711->slave) 1417 return -EINVAL; 1418 1419 sdw_stream_remove_slave(rt711->slave, sdw_stream); 1420 return 0; 1421 } 1422 1423 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ 1424 SNDRV_PCM_RATE_192000) 1425 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \ 1426 SNDRV_PCM_FMTBIT_S24_LE) 1427 1428 static const struct snd_soc_dai_ops rt711_sdca_ops = { 1429 .hw_params = rt711_sdca_pcm_hw_params, 1430 .hw_free = rt711_sdca_pcm_hw_free, 1431 .set_stream = rt711_sdca_set_sdw_stream, 1432 .shutdown = rt711_sdca_shutdown, 1433 }; 1434 1435 static struct snd_soc_dai_driver rt711_sdca_dai[] = { 1436 { 1437 .name = "rt711-sdca-aif1", 1438 .id = RT711_AIF1, 1439 .playback = { 1440 .stream_name = "DP3 Playback", 1441 .channels_min = 1, 1442 .channels_max = 2, 1443 .rates = RT711_STEREO_RATES, 1444 .formats = RT711_FORMATS, 1445 }, 1446 .capture = { 1447 .stream_name = "DP2 Capture", 1448 .channels_min = 1, 1449 .channels_max = 2, 1450 .rates = RT711_STEREO_RATES, 1451 .formats = RT711_FORMATS, 1452 }, 1453 .ops = &rt711_sdca_ops, 1454 }, 1455 { 1456 .name = "rt711-sdca-aif2", 1457 .id = RT711_AIF2, 1458 .capture = { 1459 .stream_name = "DP4 Capture", 1460 .channels_min = 1, 1461 .channels_max = 2, 1462 .rates = RT711_STEREO_RATES, 1463 .formats = RT711_FORMATS, 1464 }, 1465 .ops = &rt711_sdca_ops, 1466 } 1467 }; 1468 1469 int rt711_sdca_init(struct device *dev, struct regmap *regmap, 1470 struct regmap *mbq_regmap, struct sdw_slave *slave) 1471 { 1472 struct rt711_sdca_priv *rt711; 1473 int ret; 1474 1475 rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL); 1476 if (!rt711) 1477 return -ENOMEM; 1478 1479 dev_set_drvdata(dev, rt711); 1480 rt711->slave = slave; 1481 rt711->regmap = regmap; 1482 rt711->mbq_regmap = mbq_regmap; 1483 1484 regcache_cache_only(rt711->regmap, true); 1485 regcache_cache_only(rt711->mbq_regmap, true); 1486 1487 mutex_init(&rt711->calibrate_mutex); 1488 mutex_init(&rt711->disable_irq_lock); 1489 1490 INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_sdca_jack_detect_handler); 1491 INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_sdca_btn_check_handler); 1492 1493 /* 1494 * Mark hw_init to false 1495 * HW init will be performed when device reports present 1496 */ 1497 rt711->hw_init = false; 1498 rt711->first_hw_init = false; 1499 rt711->fu0f_dapm_mute = true; 1500 rt711->fu1e_dapm_mute = true; 1501 rt711->fu0f_mixer_l_mute = rt711->fu0f_mixer_r_mute = true; 1502 rt711->fu1e_mixer_l_mute = rt711->fu1e_mixer_r_mute = true; 1503 1504 /* JD source uses JD2 in default */ 1505 rt711->jd_src = RT711_JD2; 1506 1507 ret = devm_snd_soc_register_component(dev, 1508 &soc_sdca_dev_rt711, 1509 rt711_sdca_dai, 1510 ARRAY_SIZE(rt711_sdca_dai)); 1511 1512 if (ret < 0) 1513 return ret; 1514 1515 /* set autosuspend parameters */ 1516 pm_runtime_set_autosuspend_delay(dev, 3000); 1517 pm_runtime_use_autosuspend(dev); 1518 1519 /* make sure the device does not suspend immediately */ 1520 pm_runtime_mark_last_busy(dev); 1521 1522 pm_runtime_enable(dev); 1523 1524 /* important note: the device is NOT tagged as 'active' and will remain 1525 * 'suspended' until the hardware is enumerated/initialized. This is required 1526 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently 1527 * fail with -EACCESS because of race conditions between card creation and enumeration 1528 */ 1529 1530 dev_dbg(dev, "%s\n", __func__); 1531 1532 return 0; 1533 } 1534 1535 static void rt711_sdca_vd0_io_init(struct rt711_sdca_priv *rt711) 1536 { 1537 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1538 RT711_GPIO_TEST_MODE_CTL2, 0x0e00); 1539 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1540 RT711_HDA_LEGACY_GPIO_CTL, 0x0008); 1541 1542 regmap_write(rt711->regmap, 0x2f5a, 0x01); 1543 1544 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1545 RT711_ADC27_VOL_SET, 0x8728); 1546 1547 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1548 RT711_COMBO_JACK_AUTO_CTL3, 0xa472); 1549 1550 regmap_write(rt711->regmap, 0x2f50, 0x02); 1551 1552 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL, 1553 RT711_MISC_POWER_CTL4, 0x6000, 0x6000); 1554 1555 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 1556 RT711_COMBO_JACK_AUTO_CTL3, 0x000c, 0x000c); 1557 1558 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1559 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000); 1560 1561 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD, 1562 RT711_VAD_SRAM_CTL1, 0x0050); 1563 } 1564 1565 static void rt711_sdca_vd1_io_init(struct rt711_sdca_priv *rt711) 1566 { 1567 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 1568 RT711_HDA_LEGACY_UNSOLICITED_CTL, 0x0300, 0x0000); 1569 1570 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1571 RT711_COMBO_JACK_AUTO_CTL3, 0xa43e); 1572 1573 regmap_write(rt711->regmap, 0x2f5a, 0x05); 1574 1575 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1576 RT711_JD_CTRL6, 0x0500); 1577 1578 rt711_sdca_index_write(rt711, RT711_VENDOR_REG, 1579 RT711_DMIC_CTL1, 0x6173); 1580 1581 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL, 1582 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000); 1583 1584 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD, 1585 RT711_VAD_SRAM_CTL1, 0x0050); 1586 } 1587 1588 int rt711_sdca_io_init(struct device *dev, struct sdw_slave *slave) 1589 { 1590 struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev); 1591 int ret = 0; 1592 unsigned int val; 1593 1594 rt711->disable_irq = false; 1595 1596 if (rt711->hw_init) 1597 return 0; 1598 1599 regcache_cache_only(rt711->regmap, false); 1600 regcache_cache_only(rt711->mbq_regmap, false); 1601 1602 if (rt711->first_hw_init) { 1603 regcache_cache_bypass(rt711->regmap, true); 1604 regcache_cache_bypass(rt711->mbq_regmap, true); 1605 } else { 1606 /* 1607 * PM runtime status is marked as 'active' only when a Slave reports as Attached 1608 */ 1609 1610 /* update count of parent 'active' children */ 1611 pm_runtime_set_active(&slave->dev); 1612 } 1613 1614 pm_runtime_get_noresume(&slave->dev); 1615 1616 rt711_sdca_reset(rt711); 1617 1618 rt711_sdca_index_read(rt711, RT711_VENDOR_REG, RT711_JD_PRODUCT_NUM, &val); 1619 rt711->hw_ver = val & 0xf; 1620 1621 if (rt711->hw_ver == RT711_VER_VD0) 1622 rt711_sdca_vd0_io_init(rt711); 1623 else 1624 rt711_sdca_vd1_io_init(rt711); 1625 1626 /* DP4 mux select from 08_filter_Out_pri */ 1627 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, 1628 RT711_FILTER_SRC_SEL, 0x1800, 0x0800); 1629 1630 /* ge_exclusive_inbox_en disable */ 1631 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, 1632 RT711_PUSH_BTN_INT_CTL0, 0x20, 0x00); 1633 1634 /* calibration */ 1635 ret = rt711_sdca_calibration(rt711); 1636 if (ret < 0) 1637 dev_err(dev, "%s, calibration failed!\n", __func__); 1638 1639 /* HP output enable */ 1640 regmap_write(rt711->regmap, 1641 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_OT1, RT711_SDCA_CTL_VENDOR_DEF, 0), 0x4); 1642 1643 /* 1644 * if set_jack callback occurred early than io_init, 1645 * we set up the jack detection function now 1646 */ 1647 if (rt711->hs_jack) 1648 rt711_sdca_jack_init(rt711); 1649 1650 if (rt711->first_hw_init) { 1651 regcache_cache_bypass(rt711->regmap, false); 1652 regcache_mark_dirty(rt711->regmap); 1653 regcache_cache_bypass(rt711->mbq_regmap, false); 1654 regcache_mark_dirty(rt711->mbq_regmap); 1655 } else 1656 rt711->first_hw_init = true; 1657 1658 /* Mark Slave initialization complete */ 1659 rt711->hw_init = true; 1660 1661 pm_runtime_put_autosuspend(&slave->dev); 1662 1663 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1664 return 0; 1665 } 1666 1667 MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver"); 1668 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1669 MODULE_LICENSE("GPL"); 1670