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