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