1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // rt712-sdca.c -- rt712 SDCA ALSA SoC audio driver 4 // 5 // Copyright(c) 2023 Realtek Semiconductor Corp. 6 // 7 // 8 9 #include <linux/bitops.h> 10 #include <linux/cleanup.h> 11 #include <sound/core.h> 12 #include <linux/delay.h> 13 #include <linux/init.h> 14 #include <sound/initval.h> 15 #include <sound/jack.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/moduleparam.h> 19 #include <linux/pm_runtime.h> 20 #include <sound/pcm.h> 21 #include <sound/pcm_params.h> 22 #include <sound/sdca.h> 23 #include <linux/soundwire/sdw_registers.h> 24 #include <linux/slab.h> 25 #include <sound/soc-dapm.h> 26 #include <sound/tlv.h> 27 #include "rt712-sdca.h" 28 29 static int rt712_sdca_index_write(struct rt712_sdca_priv *rt712, 30 unsigned int nid, unsigned int reg, unsigned int value) 31 { 32 int ret; 33 struct regmap *regmap = rt712->mbq_regmap; 34 unsigned int addr = (nid << 20) | reg; 35 36 ret = regmap_write(regmap, addr, value); 37 if (ret < 0) 38 dev_err(&rt712->slave->dev, 39 "%s: Failed to set private value: %06x <= %04x ret=%d\n", 40 __func__, addr, value, ret); 41 42 return ret; 43 } 44 45 static int rt712_sdca_index_read(struct rt712_sdca_priv *rt712, 46 unsigned int nid, unsigned int reg, unsigned int *value) 47 { 48 int ret; 49 struct regmap *regmap = rt712->mbq_regmap; 50 unsigned int addr = (nid << 20) | reg; 51 52 ret = regmap_read(regmap, addr, value); 53 if (ret < 0) 54 dev_err(&rt712->slave->dev, 55 "%s: Failed to get private value: %06x => %04x ret=%d\n", 56 __func__, addr, *value, ret); 57 58 return ret; 59 } 60 61 static int rt712_sdca_index_update_bits(struct rt712_sdca_priv *rt712, 62 unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val) 63 { 64 unsigned int tmp; 65 int ret; 66 67 ret = rt712_sdca_index_read(rt712, nid, reg, &tmp); 68 if (ret < 0) 69 return ret; 70 71 set_mask_bits(&tmp, mask, val); 72 return rt712_sdca_index_write(rt712, nid, reg, tmp); 73 } 74 75 static int rt712_sdca_calibration(struct rt712_sdca_priv *rt712) 76 { 77 unsigned int val, loop_rc = 0, loop_dc = 0; 78 struct device *dev; 79 struct regmap *regmap = rt712->regmap; 80 int chk_cnt = 100; 81 int ret = 0; 82 83 mutex_lock(&rt712->calibrate_mutex); 84 dev = regmap_get_device(regmap); 85 86 /* Set HP-JD source from JD1 */ 87 if (rt712->version_id == RT712_VA) 88 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, 0x043a); 89 90 /* FSM switch to calibration manual mode */ 91 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, 0x4100); 92 93 /* Calibration setting */ 94 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, 0x7883); 95 96 /* W1C Trigger DC calibration (HP & Class-D) */ 97 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, 0xf893); 98 99 /* wait for calibration process */ 100 rt712_sdca_index_read(rt712, RT712_VENDOR_CALI, 101 RT712_DAC_DC_CALI_CTL1, &val); 102 103 for (loop_dc = 0; loop_dc < chk_cnt && 104 (val & RT712_DAC_DC_CALI_TRIGGER); loop_dc++) { 105 usleep_range(10000, 11000); 106 ret = rt712_sdca_index_read(rt712, RT712_VENDOR_CALI, 107 RT712_DAC_DC_CALI_CTL1, &val); 108 if (ret < 0) 109 goto _cali_fail_; 110 } 111 if (loop_dc == chk_cnt) 112 dev_err(dev, "%s, calibration time-out!\n", __func__); 113 114 if (loop_dc == chk_cnt || loop_rc == chk_cnt) 115 ret = -ETIMEDOUT; 116 117 _cali_fail_: 118 /* Enable Rldet in FSM */ 119 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, 0x4500); 120 121 /* Sensing Lch+Rch */ 122 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL1, 0x040f); 123 124 /* Sine gen path control */ 125 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL5, 0x0000); 126 127 /* Release HP-JD, EN_CBJ_TIE_GL/R open, en_osw gating auto done bit */ 128 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_DIGITAL_MISC_CTRL4, 0x0010); 129 130 mutex_unlock(&rt712->calibrate_mutex); 131 dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret); 132 return ret; 133 } 134 135 static unsigned int rt712_sdca_button_detect(struct rt712_sdca_priv *rt712) 136 { 137 unsigned int btn_type = 0, offset, idx, val, owner; 138 int ret; 139 unsigned char buf[3]; 140 141 /* get current UMP message owner */ 142 ret = regmap_read(rt712->regmap, 143 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0), 144 &owner); 145 if (ret < 0) 146 return 0; 147 148 /* if owner is device then there is no button event from device */ 149 if (owner == 1) 150 return 0; 151 152 /* read UMP message offset */ 153 ret = regmap_read(rt712->regmap, 154 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0), 155 &offset); 156 if (ret < 0) 157 goto _end_btn_det_; 158 159 for (idx = 0; idx < sizeof(buf); idx++) { 160 ret = regmap_read(rt712->regmap, 161 RT712_BUF_ADDR_HID1 + offset + idx, &val); 162 if (ret < 0) 163 goto _end_btn_det_; 164 buf[idx] = val & 0xff; 165 } 166 167 if (buf[0] == 0x11) { 168 switch (buf[1] & 0xf0) { 169 case 0x10: 170 btn_type |= SND_JACK_BTN_2; 171 break; 172 case 0x20: 173 btn_type |= SND_JACK_BTN_3; 174 break; 175 case 0x40: 176 btn_type |= SND_JACK_BTN_0; 177 break; 178 case 0x80: 179 btn_type |= SND_JACK_BTN_1; 180 break; 181 } 182 switch (buf[2]) { 183 case 0x01: 184 case 0x10: 185 btn_type |= SND_JACK_BTN_2; 186 break; 187 case 0x02: 188 case 0x20: 189 btn_type |= SND_JACK_BTN_3; 190 break; 191 case 0x04: 192 case 0x40: 193 btn_type |= SND_JACK_BTN_0; 194 break; 195 case 0x08: 196 case 0x80: 197 btn_type |= SND_JACK_BTN_1; 198 break; 199 } 200 } 201 202 _end_btn_det_: 203 /* Host is owner, so set back to device */ 204 if (owner == 0) { 205 /* set owner to device */ 206 if (rt712->version_id == RT712_VA) 207 regmap_write(rt712->regmap, 208 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, 209 RT712_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01); 210 else 211 regmap_write(rt712->regmap, 212 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, 213 RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0), 0x01); 214 } 215 216 return btn_type; 217 } 218 219 static int rt712_sdca_headset_detect(struct rt712_sdca_priv *rt712) 220 { 221 unsigned int det_mode; 222 int ret; 223 224 /* get detected_mode */ 225 ret = regmap_read(rt712->regmap, 226 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0), 227 &det_mode); 228 if (ret < 0) 229 goto io_error; 230 231 switch (det_mode) { 232 case 0x00: 233 rt712->jack_type = 0; 234 break; 235 case 0x03: 236 rt712->jack_type = SND_JACK_HEADPHONE; 237 break; 238 case 0x05: 239 rt712->jack_type = SND_JACK_HEADSET; 240 break; 241 } 242 243 /* write selected_mode */ 244 if (det_mode) { 245 ret = regmap_write(rt712->regmap, 246 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_SELECTED_MODE, 0), 247 det_mode); 248 if (ret < 0) 249 goto io_error; 250 } 251 252 dev_dbg(&rt712->slave->dev, 253 "%s, detected_mode=0x%x\n", __func__, det_mode); 254 255 return 0; 256 257 io_error: 258 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 259 return ret; 260 } 261 262 static void rt712_sdca_jack_detect_handler(struct work_struct *work) 263 { 264 struct rt712_sdca_priv *rt712 = 265 container_of(work, struct rt712_sdca_priv, jack_detect_work.work); 266 int btn_type = 0, ret; 267 268 if (!rt712->hs_jack) 269 return; 270 271 if (!rt712->component->card || !rt712->component->card->instantiated) 272 return; 273 274 /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */ 275 if (rt712->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) { 276 ret = rt712_sdca_headset_detect(rt712); 277 if (ret < 0) 278 return; 279 } 280 281 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */ 282 if (rt712->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8) 283 btn_type = rt712_sdca_button_detect(rt712); 284 285 if (rt712->jack_type == 0) 286 btn_type = 0; 287 288 dev_dbg(&rt712->slave->dev, 289 "in %s, jack_type=0x%x\n", __func__, rt712->jack_type); 290 dev_dbg(&rt712->slave->dev, 291 "in %s, btn_type=0x%x\n", __func__, btn_type); 292 dev_dbg(&rt712->slave->dev, 293 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__, 294 rt712->scp_sdca_stat1, rt712->scp_sdca_stat2); 295 296 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type | btn_type, 297 SND_JACK_HEADSET | 298 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 299 SND_JACK_BTN_2 | SND_JACK_BTN_3); 300 301 if (btn_type) { 302 /* button released */ 303 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type, 304 SND_JACK_HEADSET | 305 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 306 SND_JACK_BTN_2 | SND_JACK_BTN_3); 307 308 mod_delayed_work(system_power_efficient_wq, 309 &rt712->jack_btn_check_work, msecs_to_jiffies(200)); 310 } 311 } 312 313 static void rt712_sdca_btn_check_handler(struct work_struct *work) 314 { 315 struct rt712_sdca_priv *rt712 = 316 container_of(work, struct rt712_sdca_priv, jack_btn_check_work.work); 317 int btn_type = 0, ret, idx; 318 unsigned int det_mode, offset, val; 319 unsigned char buf[3]; 320 321 ret = regmap_read(rt712->regmap, 322 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0), 323 &det_mode); 324 if (ret < 0) 325 goto io_error; 326 327 /* pin attached */ 328 if (det_mode) { 329 /* read UMP message offset */ 330 ret = regmap_read(rt712->regmap, 331 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0), 332 &offset); 333 if (ret < 0) 334 goto io_error; 335 336 for (idx = 0; idx < sizeof(buf); idx++) { 337 ret = regmap_read(rt712->regmap, 338 RT712_BUF_ADDR_HID1 + offset + idx, &val); 339 if (ret < 0) 340 goto io_error; 341 buf[idx] = val & 0xff; 342 } 343 344 if (buf[0] == 0x11) { 345 switch (buf[1] & 0xf0) { 346 case 0x10: 347 btn_type |= SND_JACK_BTN_2; 348 break; 349 case 0x20: 350 btn_type |= SND_JACK_BTN_3; 351 break; 352 case 0x40: 353 btn_type |= SND_JACK_BTN_0; 354 break; 355 case 0x80: 356 btn_type |= SND_JACK_BTN_1; 357 break; 358 } 359 switch (buf[2]) { 360 case 0x01: 361 case 0x10: 362 btn_type |= SND_JACK_BTN_2; 363 break; 364 case 0x02: 365 case 0x20: 366 btn_type |= SND_JACK_BTN_3; 367 break; 368 case 0x04: 369 case 0x40: 370 btn_type |= SND_JACK_BTN_0; 371 break; 372 case 0x08: 373 case 0x80: 374 btn_type |= SND_JACK_BTN_1; 375 break; 376 } 377 } 378 } else { 379 rt712->jack_type = 0; 380 } 381 382 dev_dbg(&rt712->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type); 383 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type | btn_type, 384 SND_JACK_HEADSET | 385 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 386 SND_JACK_BTN_2 | SND_JACK_BTN_3); 387 388 if (btn_type) { 389 /* button released */ 390 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type, 391 SND_JACK_HEADSET | 392 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 393 SND_JACK_BTN_2 | SND_JACK_BTN_3); 394 395 mod_delayed_work(system_power_efficient_wq, 396 &rt712->jack_btn_check_work, msecs_to_jiffies(200)); 397 } 398 399 return; 400 401 io_error: 402 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 403 } 404 405 static void rt712_sdca_jack_init(struct rt712_sdca_priv *rt712) 406 { 407 guard(mutex)(&rt712->calibrate_mutex); 408 409 if (rt712->hs_jack) { 410 /* Enable HID1 event & set button RTC mode */ 411 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, 412 RT712_UMP_HID_CTL5, 0xfff0); 413 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 414 RT712_UMP_HID_CTL0, 0x1100, 0x1100); 415 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 416 RT712_UMP_HID_CTL7, 0xf000, 0x0000); 417 418 /* detected_mode_change_event_en & hid1_push_button_event_en */ 419 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 420 RT712_GE_RELATED_CTL1, 0x0c00, 0x0c00); 421 /* ge_inbox_en */ 422 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 423 RT712_GE_RELATED_CTL2, 0x0020, 0x0000); 424 425 switch (rt712->jd_src) { 426 case RT712_JD1: 427 /* Set HP-JD source from JD1, VB uses JD1 in default */ 428 if (rt712->version_id == RT712_VA) 429 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, 0x043a); 430 break; 431 default: 432 dev_warn(rt712->component->dev, "Wrong JD source\n"); 433 break; 434 } 435 436 /* set SCP_SDCA_IntMask1[0]=1 */ 437 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0); 438 /* set SCP_SDCA_IntMask2[0]=1 */ 439 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8); 440 dev_dbg(&rt712->slave->dev, "in %s enable\n", __func__); 441 442 /* trigger GE interrupt */ 443 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 444 RT712_GE_RELATED_CTL1, 0x0080, 0x0080); 445 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 446 RT712_GE_RELATED_CTL1, 0x0080, 0x0000); 447 } else { 448 /* disable HID1 & detected_mode_change event */ 449 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 450 RT712_GE_RELATED_CTL1, 0x0c00, 0x0000); 451 452 dev_dbg(&rt712->slave->dev, "in %s disable\n", __func__); 453 } 454 } 455 456 static int rt712_sdca_set_jack_detect(struct snd_soc_component *component, 457 struct snd_soc_jack *hs_jack, void *data) 458 { 459 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 460 int ret; 461 462 rt712->hs_jack = hs_jack; 463 464 if (!rt712->first_hw_init) 465 return 0; 466 467 ret = pm_runtime_resume_and_get(component->dev); 468 if (ret < 0) { 469 if (ret != -EACCES) { 470 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret); 471 return ret; 472 } 473 474 /* pm_runtime not enabled yet */ 475 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__); 476 return 0; 477 } 478 479 rt712_sdca_jack_init(rt712); 480 481 pm_runtime_put_autosuspend(component->dev); 482 483 return 0; 484 } 485 486 /* For SDCA control DAC/ADC Gain */ 487 static int rt712_sdca_set_gain_put(struct snd_kcontrol *kcontrol, 488 struct snd_ctl_elem_value *ucontrol) 489 { 490 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 491 struct soc_mixer_control *mc = 492 (struct soc_mixer_control *)kcontrol->private_value; 493 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 494 unsigned int read_l, read_r, gain_l_val, gain_r_val; 495 unsigned int adc_vol_flag = 0; 496 unsigned int lvalue, rvalue; 497 const unsigned int interval_offset = 0xc0; 498 const unsigned int tendB = 0xa00; 499 500 if (strstr(ucontrol->id.name, "FU0F Capture Volume")) 501 adc_vol_flag = 1; 502 503 regmap_read(rt712->mbq_regmap, mc->reg, &lvalue); 504 regmap_read(rt712->mbq_regmap, mc->rreg, &rvalue); 505 506 /* L Channel */ 507 gain_l_val = ucontrol->value.integer.value[0]; 508 if (gain_l_val > mc->max) 509 gain_l_val = mc->max; 510 511 if (mc->shift == 8) /* boost gain */ 512 gain_l_val = gain_l_val * tendB; 513 else { 514 /* ADC/DAC gain */ 515 if (adc_vol_flag) 516 gain_l_val = 0x1e00 - ((mc->max - gain_l_val) * interval_offset); 517 else 518 gain_l_val = 0 - ((mc->max - gain_l_val) * interval_offset); 519 gain_l_val &= 0xffff; 520 } 521 522 /* R Channel */ 523 gain_r_val = ucontrol->value.integer.value[1]; 524 if (gain_r_val > mc->max) 525 gain_r_val = mc->max; 526 527 if (mc->shift == 8) /* boost gain */ 528 gain_r_val = gain_r_val * tendB; 529 else { 530 /* ADC/DAC gain */ 531 if (adc_vol_flag) 532 gain_r_val = 0x1e00 - ((mc->max - gain_r_val) * interval_offset); 533 else 534 gain_r_val = 0 - ((mc->max - gain_r_val) * interval_offset); 535 gain_r_val &= 0xffff; 536 } 537 538 if (lvalue == gain_l_val && rvalue == gain_r_val) 539 return 0; 540 541 /* Lch*/ 542 regmap_write(rt712->mbq_regmap, mc->reg, gain_l_val); 543 /* Rch */ 544 regmap_write(rt712->mbq_regmap, mc->rreg, gain_r_val); 545 546 regmap_read(rt712->mbq_regmap, mc->reg, &read_l); 547 regmap_read(rt712->mbq_regmap, mc->rreg, &read_r); 548 if (read_r == gain_r_val && read_l == gain_l_val) 549 return 1; 550 551 return -EIO; 552 } 553 554 static int rt712_sdca_set_gain_get(struct snd_kcontrol *kcontrol, 555 struct snd_ctl_elem_value *ucontrol) 556 { 557 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 558 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 559 struct soc_mixer_control *mc = 560 (struct soc_mixer_control *)kcontrol->private_value; 561 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0; 562 unsigned int adc_vol_flag = 0; 563 const unsigned int interval_offset = 0xc0; 564 const unsigned int tendB = 0xa00; 565 566 if (strstr(ucontrol->id.name, "FU0F Capture Volume")) 567 adc_vol_flag = 1; 568 569 regmap_read(rt712->mbq_regmap, mc->reg, &read_l); 570 regmap_read(rt712->mbq_regmap, mc->rreg, &read_r); 571 572 if (mc->shift == 8) /* boost gain */ 573 ctl_l = read_l / tendB; 574 else { 575 if (adc_vol_flag) 576 ctl_l = mc->max - (((0x1e00 - read_l) & 0xffff) / interval_offset); 577 else 578 ctl_l = mc->max - (((0 - read_l) & 0xffff) / interval_offset); 579 } 580 581 if (read_l != read_r) { 582 if (mc->shift == 8) /* boost gain */ 583 ctl_r = read_r / tendB; 584 else { /* ADC/DAC gain */ 585 if (adc_vol_flag) 586 ctl_r = mc->max - (((0x1e00 - read_r) & 0xffff) / interval_offset); 587 else 588 ctl_r = mc->max - (((0 - read_r) & 0xffff) / interval_offset); 589 } 590 } else 591 ctl_r = ctl_l; 592 593 ucontrol->value.integer.value[0] = ctl_l; 594 ucontrol->value.integer.value[1] = ctl_r; 595 596 return 0; 597 } 598 599 static int rt712_sdca_set_fu0f_capture_ctl(struct rt712_sdca_priv *rt712) 600 { 601 int err; 602 unsigned int ch_01, ch_02; 603 604 ch_01 = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_l_mute) ? 0x01 : 0x00; 605 ch_02 = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_r_mute) ? 0x01 : 0x00; 606 607 err = regmap_write(rt712->regmap, 608 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, 609 RT712_SDCA_CTL_FU_MUTE, CH_01), ch_01); 610 if (err < 0) 611 return err; 612 613 err = regmap_write(rt712->regmap, 614 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, 615 RT712_SDCA_CTL_FU_MUTE, CH_02), ch_02); 616 if (err < 0) 617 return err; 618 619 return 0; 620 } 621 622 static int rt712_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol, 623 struct snd_ctl_elem_value *ucontrol) 624 { 625 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 626 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 627 628 ucontrol->value.integer.value[0] = !rt712->fu0f_mixer_l_mute; 629 ucontrol->value.integer.value[1] = !rt712->fu0f_mixer_r_mute; 630 return 0; 631 } 632 633 static int rt712_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol, 634 struct snd_ctl_elem_value *ucontrol) 635 { 636 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 637 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 638 int err; 639 640 if (rt712->fu0f_mixer_l_mute == !ucontrol->value.integer.value[0] && 641 rt712->fu0f_mixer_r_mute == !ucontrol->value.integer.value[1]) 642 return 0; 643 644 rt712->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0]; 645 rt712->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1]; 646 err = rt712_sdca_set_fu0f_capture_ctl(rt712); 647 if (err < 0) 648 return err; 649 650 return 1; 651 } 652 653 static int rt712_sdca_set_fu05_playback_ctl(struct rt712_sdca_priv *rt712) 654 { 655 int err; 656 unsigned int ch_01, ch_02; 657 658 ch_01 = (rt712->fu05_dapm_mute || rt712->fu05_mixer_l_mute) ? 0x01 : 0x00; 659 ch_02 = (rt712->fu05_dapm_mute || rt712->fu05_mixer_r_mute) ? 0x01 : 0x00; 660 661 err = regmap_write(rt712->regmap, 662 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, 663 RT712_SDCA_CTL_FU_MUTE, CH_01), ch_01); 664 if (err < 0) 665 return err; 666 667 err = regmap_write(rt712->regmap, 668 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, 669 RT712_SDCA_CTL_FU_MUTE, CH_02), ch_02); 670 if (err < 0) 671 return err; 672 673 return 0; 674 } 675 676 static int rt712_sdca_fu05_playback_get(struct snd_kcontrol *kcontrol, 677 struct snd_ctl_elem_value *ucontrol) 678 { 679 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 680 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 681 682 ucontrol->value.integer.value[0] = !rt712->fu05_mixer_l_mute; 683 ucontrol->value.integer.value[1] = !rt712->fu05_mixer_r_mute; 684 return 0; 685 } 686 687 static int rt712_sdca_fu05_playback_put(struct snd_kcontrol *kcontrol, 688 struct snd_ctl_elem_value *ucontrol) 689 { 690 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 691 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 692 int err; 693 694 if (rt712->fu05_mixer_l_mute == !ucontrol->value.integer.value[0] && 695 rt712->fu05_mixer_r_mute == !ucontrol->value.integer.value[1]) 696 return 0; 697 698 rt712->fu05_mixer_l_mute = !ucontrol->value.integer.value[0]; 699 rt712->fu05_mixer_r_mute = !ucontrol->value.integer.value[1]; 700 701 err = rt712_sdca_set_fu05_playback_ctl(rt712); 702 if (err < 0) 703 return err; 704 705 return 1; 706 } 707 708 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0); 709 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -1725, 75, 0); 710 static const DECLARE_TLV_DB_SCALE(boost_vol_tlv, 0, 1000, 0); 711 712 static const struct snd_kcontrol_new rt712_sdca_controls[] = { 713 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume", 714 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_01), 715 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_02), 716 0, 0x57, 0, 717 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv), 718 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0, 719 rt712_sdca_fu0f_capture_get, rt712_sdca_fu0f_capture_put), 720 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume", 721 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_01), 722 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_02), 723 0, 0x3f, 0, 724 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, mic_vol_tlv), 725 SOC_DOUBLE_R_EXT_TLV("FU44 Boost Volume", 726 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_01), 727 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_02), 728 8, 3, 0, 729 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, boost_vol_tlv), 730 SOC_DOUBLE_EXT("FU05 Playback Switch", SND_SOC_NOPM, 0, 1, 1, 0, 731 rt712_sdca_fu05_playback_get, rt712_sdca_fu05_playback_put), 732 }; 733 734 static const struct snd_kcontrol_new rt712_sdca_spk_controls[] = { 735 SOC_DOUBLE_R_EXT_TLV("FU06 Playback Volume", 736 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_01), 737 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_02), 738 0, 0x57, 0, 739 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv), 740 }; 741 742 static int rt712_sdca_mux_get(struct snd_kcontrol *kcontrol, 743 struct snd_ctl_elem_value *ucontrol) 744 { 745 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol); 746 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 747 unsigned int val = 0, mask = 0x3300; 748 749 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, &val); 750 751 val = val & mask; 752 switch (val) { 753 case 0x3000: 754 val = 1; 755 break; 756 case 0x0300: 757 val = 0; 758 break; 759 } 760 761 ucontrol->value.enumerated.item[0] = val; 762 763 return 0; 764 } 765 766 static int rt712_sdca_mux_put(struct snd_kcontrol *kcontrol, 767 struct snd_ctl_elem_value *ucontrol) 768 { 769 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol); 770 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol); 771 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 772 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 773 unsigned int *item = ucontrol->value.enumerated.item; 774 unsigned int mask_sft; 775 unsigned int val; 776 777 if (item[0] >= e->items) 778 return -EINVAL; 779 780 if (ucontrol->value.enumerated.item[0] == 0) 781 mask_sft = 12; 782 else if (ucontrol->value.enumerated.item[0] == 1) 783 mask_sft = 8; 784 else 785 return -EINVAL; 786 787 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, &val); 788 val = (val >> mask_sft) & 0x3; 789 if (!val) 790 return 0; 791 792 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, 793 RT712_MIXER_CTL1, 0x3fff); 794 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 795 RT712_MIXER_CTL1, 0x3 << mask_sft, 0); 796 797 snd_soc_dapm_mux_update_power(dapm, kcontrol, 798 item[0], e, NULL); 799 800 return 1; 801 } 802 803 static const char * const adc_mux_text[] = { 804 "MIC2", 805 "LINE2", 806 }; 807 808 static SOC_ENUM_SINGLE_DECL( 809 rt712_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text); 810 811 static const struct snd_kcontrol_new rt712_sdca_adc23_mux = 812 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt712_adc23_enum, 813 rt712_sdca_mux_get, rt712_sdca_mux_put); 814 815 static int rt712_sdca_fu05_event(struct snd_soc_dapm_widget *w, 816 struct snd_kcontrol *kcontrol, int event) 817 { 818 struct snd_soc_component *component = 819 snd_soc_dapm_to_component(w->dapm); 820 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 821 822 switch (event) { 823 case SND_SOC_DAPM_POST_PMU: 824 rt712->fu05_dapm_mute = false; 825 rt712_sdca_set_fu05_playback_ctl(rt712); 826 break; 827 case SND_SOC_DAPM_PRE_PMD: 828 rt712->fu05_dapm_mute = true; 829 rt712_sdca_set_fu05_playback_ctl(rt712); 830 break; 831 } 832 return 0; 833 } 834 835 static int rt712_sdca_fu0f_event(struct snd_soc_dapm_widget *w, 836 struct snd_kcontrol *kcontrol, int event) 837 { 838 struct snd_soc_component *component = 839 snd_soc_dapm_to_component(w->dapm); 840 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 841 842 switch (event) { 843 case SND_SOC_DAPM_POST_PMU: 844 rt712->fu0f_dapm_mute = false; 845 rt712_sdca_set_fu0f_capture_ctl(rt712); 846 break; 847 case SND_SOC_DAPM_PRE_PMD: 848 rt712->fu0f_dapm_mute = true; 849 rt712_sdca_set_fu0f_capture_ctl(rt712); 850 break; 851 } 852 return 0; 853 } 854 855 static int rt712_sdca_pde40_event(struct snd_soc_dapm_widget *w, 856 struct snd_kcontrol *kcontrol, int event) 857 { 858 struct snd_soc_component *component = 859 snd_soc_dapm_to_component(w->dapm); 860 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 861 unsigned char ps0 = 0x0, ps3 = 0x3; 862 863 switch (event) { 864 case SND_SOC_DAPM_POST_PMU: 865 regmap_write(rt712->regmap, 866 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40, 867 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 868 ps0); 869 break; 870 case SND_SOC_DAPM_PRE_PMD: 871 regmap_write(rt712->regmap, 872 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40, 873 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 874 ps3); 875 break; 876 } 877 return 0; 878 } 879 880 static int rt712_sdca_pde12_event(struct snd_soc_dapm_widget *w, 881 struct snd_kcontrol *kcontrol, int event) 882 { 883 struct snd_soc_component *component = 884 snd_soc_dapm_to_component(w->dapm); 885 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 886 unsigned char ps0 = 0x0, ps3 = 0x3; 887 888 switch (event) { 889 case SND_SOC_DAPM_POST_PMU: 890 regmap_write(rt712->regmap, 891 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12, 892 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 893 ps0); 894 break; 895 case SND_SOC_DAPM_PRE_PMD: 896 regmap_write(rt712->regmap, 897 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12, 898 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 899 ps3); 900 break; 901 } 902 return 0; 903 } 904 905 static int rt712_sdca_pde23_event(struct snd_soc_dapm_widget *w, 906 struct snd_kcontrol *kcontrol, int event) 907 { 908 struct snd_soc_component *component = 909 snd_soc_dapm_to_component(w->dapm); 910 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 911 unsigned char ps0 = 0x0, ps3 = 0x3; 912 913 switch (event) { 914 case SND_SOC_DAPM_POST_PMU: 915 regmap_write(rt712->regmap, 916 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23, 917 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 918 ps0); 919 break; 920 case SND_SOC_DAPM_PRE_PMD: 921 regmap_write(rt712->regmap, 922 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23, 923 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 924 ps3); 925 break; 926 927 default: 928 break; 929 } 930 931 return 0; 932 } 933 934 static const struct snd_kcontrol_new rt712_spk_l_dac = 935 SOC_DAPM_SINGLE_AUTODISABLE("Switch", 936 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_01), 937 0, 1, 1); 938 static const struct snd_kcontrol_new rt712_spk_r_dac = 939 SOC_DAPM_SINGLE_AUTODISABLE("Switch", 940 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_02), 941 0, 1, 1); 942 943 static const struct snd_soc_dapm_widget rt712_sdca_dapm_widgets[] = { 944 SND_SOC_DAPM_OUTPUT("HP"), 945 SND_SOC_DAPM_INPUT("MIC2"), 946 SND_SOC_DAPM_INPUT("LINE2"), 947 948 SND_SOC_DAPM_SUPPLY("PDE 40", SND_SOC_NOPM, 0, 0, 949 rt712_sdca_pde40_event, 950 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 951 SND_SOC_DAPM_SUPPLY("PDE 12", SND_SOC_NOPM, 0, 0, 952 rt712_sdca_pde12_event, 953 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 954 955 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0, 956 rt712_sdca_fu05_event, 957 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 958 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0, 959 rt712_sdca_fu0f_event, 960 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 961 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0, 962 &rt712_sdca_adc23_mux), 963 964 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0), 965 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0), 966 }; 967 968 static const struct snd_soc_dapm_route rt712_sdca_audio_map[] = { 969 { "FU 05", NULL, "DP1RX" }, 970 { "DP4TX", NULL, "FU 0F" }, 971 972 { "FU 0F", NULL, "PDE 12" }, 973 { "FU 0F", NULL, "ADC 23 Mux" }, 974 { "ADC 23 Mux", "LINE2", "LINE2" }, 975 { "ADC 23 Mux", "MIC2", "MIC2" }, 976 977 { "HP", NULL, "PDE 40" }, 978 { "HP", NULL, "FU 05" }, 979 }; 980 981 static const struct snd_soc_dapm_widget rt712_sdca_spk_dapm_widgets[] = { 982 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 983 984 /* Digital Interface */ 985 SND_SOC_DAPM_PGA("FU06", SND_SOC_NOPM, 0, 0, NULL, 0), 986 987 SND_SOC_DAPM_SUPPLY("PDE 23", SND_SOC_NOPM, 0, 0, 988 rt712_sdca_pde23_event, 989 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 990 991 /* Output */ 992 SND_SOC_DAPM_SWITCH("OT23 L", SND_SOC_NOPM, 0, 0, &rt712_spk_l_dac), 993 SND_SOC_DAPM_SWITCH("OT23 R", SND_SOC_NOPM, 0, 0, &rt712_spk_r_dac), 994 SND_SOC_DAPM_OUTPUT("SPOL"), 995 SND_SOC_DAPM_OUTPUT("SPOR"), 996 }; 997 998 static const struct snd_soc_dapm_route rt712_sdca_spk_dapm_routes[] = { 999 { "FU06", NULL, "DP3RX" }, 1000 { "FU06", NULL, "PDE 23" }, 1001 { "OT23 L", "Switch", "FU06" }, 1002 { "OT23 R", "Switch", "FU06" }, 1003 { "SPOL", NULL, "OT23 L" }, 1004 { "SPOR", NULL, "OT23 R" }, 1005 }; 1006 1007 static int rt712_sdca_parse_dt(struct rt712_sdca_priv *rt712, struct device *dev) 1008 { 1009 device_property_read_u32(dev, "realtek,jd-src", &rt712->jd_src); 1010 1011 return 0; 1012 } 1013 1014 static int rt712_sdca_probe(struct snd_soc_component *component) 1015 { 1016 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component); 1017 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1018 int ret; 1019 1020 rt712_sdca_parse_dt(rt712, &rt712->slave->dev); 1021 rt712->component = component; 1022 1023 /* add SPK route */ 1024 if (rt712->hw_id != RT712_DEV_ID_713) { 1025 snd_soc_add_component_controls(component, 1026 rt712_sdca_spk_controls, ARRAY_SIZE(rt712_sdca_spk_controls)); 1027 snd_soc_dapm_new_controls(dapm, 1028 rt712_sdca_spk_dapm_widgets, ARRAY_SIZE(rt712_sdca_spk_dapm_widgets)); 1029 snd_soc_dapm_add_routes(dapm, 1030 rt712_sdca_spk_dapm_routes, ARRAY_SIZE(rt712_sdca_spk_dapm_routes)); 1031 } 1032 1033 if (!rt712->first_hw_init) 1034 return 0; 1035 1036 ret = pm_runtime_resume(component->dev); 1037 if (ret < 0 && ret != -EACCES) 1038 return ret; 1039 1040 return 0; 1041 } 1042 1043 static int rt712_sdca_dmic_set_gain_get(struct snd_kcontrol *kcontrol, 1044 struct snd_ctl_elem_value *ucontrol) 1045 { 1046 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1047 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1048 struct rt712_dmic_kctrl_priv *p = 1049 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value; 1050 unsigned int regvalue, ctl, i; 1051 unsigned int adc_vol_flag = 0; 1052 const unsigned int interval_offset = 0xc0; 1053 1054 if (strstr(ucontrol->id.name, "FU1E Capture Volume")) 1055 adc_vol_flag = 1; 1056 1057 /* check all channels */ 1058 for (i = 0; i < p->count; i++) { 1059 regmap_read(rt712->mbq_regmap, p->reg_base + i, ®value); 1060 1061 if (!adc_vol_flag) /* boost gain */ 1062 ctl = regvalue / 0x0a00; 1063 else /* ADC gain */ 1064 ctl = p->max - (((0x1e00 - regvalue) & 0xffff) / interval_offset); 1065 1066 ucontrol->value.integer.value[i] = ctl; 1067 } 1068 1069 return 0; 1070 } 1071 1072 static int rt712_sdca_dmic_set_gain_put(struct snd_kcontrol *kcontrol, 1073 struct snd_ctl_elem_value *ucontrol) 1074 { 1075 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1076 struct rt712_dmic_kctrl_priv *p = 1077 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value; 1078 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1079 unsigned int gain_val[4]; 1080 unsigned int i, adc_vol_flag = 0, changed = 0; 1081 unsigned int regvalue[4]; 1082 const unsigned int interval_offset = 0xc0; 1083 int err; 1084 1085 if (strstr(ucontrol->id.name, "FU1E Capture Volume")) 1086 adc_vol_flag = 1; 1087 1088 /* check all channels */ 1089 for (i = 0; i < p->count; i++) { 1090 regmap_read(rt712->mbq_regmap, p->reg_base + i, ®value[i]); 1091 1092 gain_val[i] = ucontrol->value.integer.value[i]; 1093 if (gain_val[i] > p->max) 1094 gain_val[i] = p->max; 1095 1096 if (!adc_vol_flag) /* boost gain */ 1097 gain_val[i] = gain_val[i] * 0x0a00; 1098 else { /* ADC gain */ 1099 gain_val[i] = 0x1e00 - ((p->max - gain_val[i]) * interval_offset); 1100 gain_val[i] &= 0xffff; 1101 } 1102 1103 if (regvalue[i] != gain_val[i]) 1104 changed = 1; 1105 } 1106 1107 if (!changed) 1108 return 0; 1109 1110 for (i = 0; i < p->count; i++) { 1111 err = regmap_write(rt712->mbq_regmap, p->reg_base + i, gain_val[i]); 1112 if (err < 0) 1113 dev_err(&rt712->slave->dev, "0x%08x can't be set\n", p->reg_base + i); 1114 } 1115 1116 return changed; 1117 } 1118 1119 static int rt712_sdca_set_fu1e_capture_ctl(struct rt712_sdca_priv *rt712) 1120 { 1121 int err, i; 1122 unsigned int ch_mute; 1123 1124 for (i = 0; i < ARRAY_SIZE(rt712->fu1e_mixer_mute); i++) { 1125 ch_mute = (rt712->fu1e_dapm_mute || rt712->fu1e_mixer_mute[i]) ? 0x01 : 0x00; 1126 err = regmap_write(rt712->regmap, 1127 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, 1128 RT712_SDCA_CTL_FU_MUTE, CH_01) + i, ch_mute); 1129 if (err < 0) 1130 return err; 1131 } 1132 1133 return 0; 1134 } 1135 1136 static int rt712_sdca_dmic_fu1e_capture_get(struct snd_kcontrol *kcontrol, 1137 struct snd_ctl_elem_value *ucontrol) 1138 { 1139 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1140 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1141 struct rt712_dmic_kctrl_priv *p = 1142 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value; 1143 unsigned int i; 1144 1145 for (i = 0; i < p->count; i++) 1146 ucontrol->value.integer.value[i] = !rt712->fu1e_mixer_mute[i]; 1147 1148 return 0; 1149 } 1150 1151 static int rt712_sdca_dmic_fu1e_capture_put(struct snd_kcontrol *kcontrol, 1152 struct snd_ctl_elem_value *ucontrol) 1153 { 1154 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1155 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1156 struct rt712_dmic_kctrl_priv *p = 1157 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value; 1158 int err, changed = 0, i; 1159 1160 for (i = 0; i < p->count; i++) { 1161 if (rt712->fu1e_mixer_mute[i] != !ucontrol->value.integer.value[i]) 1162 changed = 1; 1163 rt712->fu1e_mixer_mute[i] = !ucontrol->value.integer.value[i]; 1164 } 1165 1166 err = rt712_sdca_set_fu1e_capture_ctl(rt712); 1167 if (err < 0) 1168 return err; 1169 1170 return changed; 1171 } 1172 1173 static int rt712_sdca_fu_info(struct snd_kcontrol *kcontrol, 1174 struct snd_ctl_elem_info *uinfo) 1175 { 1176 struct rt712_dmic_kctrl_priv *p = 1177 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value; 1178 1179 if (p->max == 1) 1180 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1181 else 1182 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1183 uinfo->count = p->count; 1184 uinfo->value.integer.min = 0; 1185 uinfo->value.integer.max = p->max; 1186 return 0; 1187 } 1188 1189 #define RT712_SDCA_PR_VALUE(xreg_base, xcount, xmax, xinvert) \ 1190 ((unsigned long)&(struct rt712_dmic_kctrl_priv) \ 1191 {.reg_base = xreg_base, .count = xcount, .max = xmax, \ 1192 .invert = xinvert}) 1193 1194 #define RT712_SDCA_FU_CTRL(xname, reg_base, xmax, xinvert, xcount) \ 1195 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \ 1196 .info = rt712_sdca_fu_info, \ 1197 .get = rt712_sdca_dmic_fu1e_capture_get, \ 1198 .put = rt712_sdca_dmic_fu1e_capture_put, \ 1199 .private_value = RT712_SDCA_PR_VALUE(reg_base, xcount, xmax, xinvert)} 1200 1201 #define RT712_SDCA_EXT_TLV(xname, reg_base, xhandler_get,\ 1202 xhandler_put, xcount, xmax, tlv_array) \ 1203 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \ 1204 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 1205 SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 1206 .tlv.p = (tlv_array), \ 1207 .info = rt712_sdca_fu_info, \ 1208 .get = xhandler_get, .put = xhandler_put, \ 1209 .private_value = RT712_SDCA_PR_VALUE(reg_base, xcount, xmax, 0) } 1210 1211 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0); 1212 static const DECLARE_TLV_DB_SCALE(dmic_vol_tlv, 0, 1000, 0); 1213 1214 static const struct snd_kcontrol_new rt712_sdca_dmic_snd_controls[] = { 1215 RT712_SDCA_FU_CTRL("FU1E Capture Switch", 1216 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_MUTE, CH_01), 1217 1, 1, 4), 1218 RT712_SDCA_EXT_TLV("FU1E Capture Volume", 1219 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_01), 1220 rt712_sdca_dmic_set_gain_get, rt712_sdca_dmic_set_gain_put, 4, 0x3f, in_vol_tlv), 1221 RT712_SDCA_EXT_TLV("FU15 Boost Volume", 1222 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_01), 1223 rt712_sdca_dmic_set_gain_get, rt712_sdca_dmic_set_gain_put, 4, 3, dmic_vol_tlv), 1224 }; 1225 1226 static int rt712_sdca_dmic_mux_get(struct snd_kcontrol *kcontrol, 1227 struct snd_ctl_elem_value *ucontrol) 1228 { 1229 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol); 1230 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1231 unsigned int val = 0, mask_sft; 1232 1233 if (strstr(ucontrol->id.name, "ADC 0A Mux")) 1234 mask_sft = 0; 1235 else if (strstr(ucontrol->id.name, "ADC 0B Mux")) 1236 mask_sft = 4; 1237 else 1238 return -EINVAL; 1239 1240 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, 1241 RT712_HDA_LEGACY_MUX_CTL0, &val); 1242 1243 ucontrol->value.enumerated.item[0] = (((val >> mask_sft) & 0xf) == 0x4) ? 0 : 1; 1244 1245 return 0; 1246 } 1247 1248 static int rt712_sdca_dmic_mux_put(struct snd_kcontrol *kcontrol, 1249 struct snd_ctl_elem_value *ucontrol) 1250 { 1251 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol); 1252 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol); 1253 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1254 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1255 unsigned int *item = ucontrol->value.enumerated.item; 1256 unsigned int val, val2 = 0, change, mask_sft; 1257 1258 if (item[0] >= e->items) 1259 return -EINVAL; 1260 1261 if (strstr(ucontrol->id.name, "ADC 0A Mux")) 1262 mask_sft = 0; 1263 else if (strstr(ucontrol->id.name, "ADC 0B Mux")) 1264 mask_sft = 4; 1265 else 1266 return -EINVAL; 1267 1268 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 1269 1270 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, 1271 RT712_HDA_LEGACY_MUX_CTL0, &val2); 1272 val2 = ((0xf << mask_sft) & val2) >> mask_sft; 1273 1274 if (val == 0) 1275 val = 0x4; 1276 else if (val >= 1) 1277 val = 0xe; 1278 1279 if (val == val2) 1280 change = 0; 1281 else 1282 change = 1; 1283 1284 if (change) 1285 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 1286 RT712_HDA_LEGACY_MUX_CTL0, 0xf << mask_sft, 1287 val << mask_sft); 1288 1289 snd_soc_dapm_mux_update_power(dapm, kcontrol, item[0], e, NULL); 1290 1291 return change; 1292 } 1293 1294 static const char * const adc_dmic_mux_text[] = { 1295 "DMIC1", 1296 "DMIC2", 1297 }; 1298 1299 static SOC_ENUM_SINGLE_DECL( 1300 rt712_adc0a_enum, SND_SOC_NOPM, 0, adc_dmic_mux_text); 1301 1302 static SOC_ENUM_SINGLE_DECL( 1303 rt712_adc0b_enum, SND_SOC_NOPM, 0, adc_dmic_mux_text); 1304 1305 static const struct snd_kcontrol_new rt712_sdca_dmic_adc0a_mux = 1306 SOC_DAPM_ENUM_EXT("ADC 0A Mux", rt712_adc0a_enum, 1307 rt712_sdca_dmic_mux_get, rt712_sdca_dmic_mux_put); 1308 1309 static const struct snd_kcontrol_new rt712_sdca_dmic_adc0b_mux = 1310 SOC_DAPM_ENUM_EXT("ADC 0B Mux", rt712_adc0b_enum, 1311 rt712_sdca_dmic_mux_get, rt712_sdca_dmic_mux_put); 1312 1313 static int rt712_sdca_dmic_fu1e_event(struct snd_soc_dapm_widget *w, 1314 struct snd_kcontrol *kcontrol, int event) 1315 { 1316 struct snd_soc_component *component = 1317 snd_soc_dapm_to_component(w->dapm); 1318 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1319 1320 switch (event) { 1321 case SND_SOC_DAPM_POST_PMU: 1322 rt712->fu1e_dapm_mute = false; 1323 rt712_sdca_set_fu1e_capture_ctl(rt712); 1324 break; 1325 case SND_SOC_DAPM_PRE_PMD: 1326 rt712->fu1e_dapm_mute = true; 1327 rt712_sdca_set_fu1e_capture_ctl(rt712); 1328 break; 1329 } 1330 return 0; 1331 } 1332 1333 static int rt712_sdca_dmic_pde11_event(struct snd_soc_dapm_widget *w, 1334 struct snd_kcontrol *kcontrol, int event) 1335 { 1336 struct snd_soc_component *component = 1337 snd_soc_dapm_to_component(w->dapm); 1338 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1339 unsigned char ps0 = 0x0, ps3 = 0x3; 1340 1341 switch (event) { 1342 case SND_SOC_DAPM_POST_PMU: 1343 regmap_write(rt712->regmap, 1344 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PDE11, 1345 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 1346 ps0); 1347 break; 1348 case SND_SOC_DAPM_PRE_PMD: 1349 regmap_write(rt712->regmap, 1350 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PDE11, 1351 RT712_SDCA_CTL_REQ_POWER_STATE, 0), 1352 ps3); 1353 break; 1354 } 1355 return 0; 1356 } 1357 1358 static const struct snd_soc_dapm_widget rt712_sdca_dmic_dapm_widgets[] = { 1359 SND_SOC_DAPM_INPUT("DMIC1"), 1360 SND_SOC_DAPM_INPUT("DMIC2"), 1361 1362 SND_SOC_DAPM_SUPPLY("PDE 11", SND_SOC_NOPM, 0, 0, 1363 rt712_sdca_dmic_pde11_event, 1364 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1365 1366 SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0, 1367 rt712_sdca_dmic_fu1e_event, 1368 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1369 SND_SOC_DAPM_MUX("ADC 0A Mux", SND_SOC_NOPM, 0, 0, 1370 &rt712_sdca_dmic_adc0a_mux), 1371 SND_SOC_DAPM_MUX("ADC 0B Mux", SND_SOC_NOPM, 0, 0, 1372 &rt712_sdca_dmic_adc0b_mux), 1373 1374 SND_SOC_DAPM_AIF_OUT("DP8TX", "DP8 Capture", 0, SND_SOC_NOPM, 0, 0), 1375 }; 1376 1377 static const struct snd_soc_dapm_route rt712_sdca_dmic_audio_map[] = { 1378 {"DP8TX", NULL, "FU 1E"}, 1379 1380 {"FU 1E", NULL, "PDE 11"}, 1381 {"FU 1E", NULL, "ADC 0A Mux"}, 1382 {"FU 1E", NULL, "ADC 0B Mux"}, 1383 {"ADC 0A Mux", "DMIC1", "DMIC1"}, 1384 {"ADC 0A Mux", "DMIC2", "DMIC2"}, 1385 {"ADC 0B Mux", "DMIC1", "DMIC1"}, 1386 {"ADC 0B Mux", "DMIC2", "DMIC2"}, 1387 }; 1388 1389 static int rt712_sdca_dmic_probe(struct snd_soc_component *component) 1390 { 1391 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1392 int ret; 1393 1394 rt712->dmic_component = component; 1395 1396 if (!rt712->first_hw_init) 1397 return 0; 1398 1399 ret = pm_runtime_resume(component->dev); 1400 if (ret < 0 && ret != -EACCES) 1401 return ret; 1402 1403 return 0; 1404 } 1405 1406 static const struct snd_soc_component_driver soc_sdca_dev_rt712 = { 1407 .probe = rt712_sdca_probe, 1408 .controls = rt712_sdca_controls, 1409 .num_controls = ARRAY_SIZE(rt712_sdca_controls), 1410 .dapm_widgets = rt712_sdca_dapm_widgets, 1411 .num_dapm_widgets = ARRAY_SIZE(rt712_sdca_dapm_widgets), 1412 .dapm_routes = rt712_sdca_audio_map, 1413 .num_dapm_routes = ARRAY_SIZE(rt712_sdca_audio_map), 1414 .set_jack = rt712_sdca_set_jack_detect, 1415 .endianness = 1, 1416 }; 1417 1418 static const struct snd_soc_component_driver soc_sdca_dev_rt712_dmic = { 1419 .probe = rt712_sdca_dmic_probe, 1420 .controls = rt712_sdca_dmic_snd_controls, 1421 .num_controls = ARRAY_SIZE(rt712_sdca_dmic_snd_controls), 1422 .dapm_widgets = rt712_sdca_dmic_dapm_widgets, 1423 .num_dapm_widgets = ARRAY_SIZE(rt712_sdca_dmic_dapm_widgets), 1424 .dapm_routes = rt712_sdca_dmic_audio_map, 1425 .num_dapm_routes = ARRAY_SIZE(rt712_sdca_dmic_audio_map), 1426 .endianness = 1, 1427 #ifdef CONFIG_DEBUG_FS 1428 .debugfs_prefix = "dmic", 1429 #endif 1430 }; 1431 1432 static int rt712_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 1433 int direction) 1434 { 1435 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 1436 1437 return 0; 1438 } 1439 1440 static void rt712_sdca_shutdown(struct snd_pcm_substream *substream, 1441 struct snd_soc_dai *dai) 1442 { 1443 snd_soc_dai_set_dma_data(dai, substream, NULL); 1444 } 1445 1446 static int rt712_sdca_pcm_hw_params(struct snd_pcm_substream *substream, 1447 struct snd_pcm_hw_params *params, 1448 struct snd_soc_dai *dai) 1449 { 1450 struct snd_soc_component *component = dai->component; 1451 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1452 struct sdw_stream_config stream_config; 1453 struct sdw_port_config port_config; 1454 enum sdw_data_direction direction; 1455 struct sdw_stream_runtime *sdw_stream; 1456 int retval, port, num_channels; 1457 unsigned int sampling_rate; 1458 1459 dev_dbg(dai->dev, "%s %s id %d", __func__, dai->name, dai->id); 1460 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 1461 1462 if (!sdw_stream) 1463 return -EINVAL; 1464 1465 if (!rt712->slave) 1466 return -EINVAL; 1467 1468 /* VA doesn't support AIF3 */ 1469 if (dai->id == RT712_AIF3 && rt712->version_id == RT712_VA) 1470 return -EINVAL; 1471 1472 /* SoundWire specific configuration */ 1473 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1474 direction = SDW_DATA_DIR_RX; 1475 if (dai->id == RT712_AIF1) 1476 port = 1; 1477 else if (dai->id == RT712_AIF2) 1478 port = 3; 1479 else 1480 return -EINVAL; 1481 } else { 1482 direction = SDW_DATA_DIR_TX; 1483 if (dai->id == RT712_AIF1) 1484 port = 4; 1485 else if (dai->id == RT712_AIF3) 1486 port = 8; 1487 else 1488 return -EINVAL; 1489 } 1490 1491 stream_config.frame_rate = params_rate(params); 1492 stream_config.ch_count = params_channels(params); 1493 stream_config.bps = snd_pcm_format_width(params_format(params)); 1494 stream_config.direction = direction; 1495 1496 num_channels = params_channels(params); 1497 port_config.ch_mask = GENMASK(num_channels - 1, 0); 1498 port_config.num = port; 1499 1500 retval = sdw_stream_add_slave(rt712->slave, &stream_config, 1501 &port_config, 1, sdw_stream); 1502 if (retval) { 1503 dev_err(dai->dev, "%s: Unable to configure port\n", __func__); 1504 return retval; 1505 } 1506 1507 if (params_channels(params) > 16) { 1508 dev_err(component->dev, "%s: Unsupported channels %d\n", 1509 __func__, params_channels(params)); 1510 return -EINVAL; 1511 } 1512 1513 /* sampling rate configuration */ 1514 switch (params_rate(params)) { 1515 case 44100: 1516 sampling_rate = RT712_SDCA_RATE_44100HZ; 1517 break; 1518 case 48000: 1519 sampling_rate = RT712_SDCA_RATE_48000HZ; 1520 break; 1521 case 96000: 1522 sampling_rate = RT712_SDCA_RATE_96000HZ; 1523 break; 1524 case 192000: 1525 sampling_rate = RT712_SDCA_RATE_192000HZ; 1526 break; 1527 default: 1528 dev_err(component->dev, "%s: Rate %d is not supported\n", 1529 __func__, params_rate(params)); 1530 return -EINVAL; 1531 } 1532 1533 /* set sampling frequency */ 1534 switch (dai->id) { 1535 case RT712_AIF1: 1536 regmap_write(rt712->regmap, 1537 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS01, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1538 sampling_rate); 1539 regmap_write(rt712->regmap, 1540 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS11, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1541 sampling_rate); 1542 break; 1543 case RT712_AIF2: 1544 regmap_write(rt712->regmap, 1545 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_CS31, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1546 sampling_rate); 1547 break; 1548 case RT712_AIF3: 1549 regmap_write(rt712->regmap, 1550 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_CS1F, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1551 sampling_rate); 1552 regmap_write(rt712->regmap, 1553 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_CS1C, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), 1554 sampling_rate); 1555 break; 1556 default: 1557 dev_err(component->dev, "%s: Wrong DAI id\n", __func__); 1558 return -EINVAL; 1559 } 1560 1561 return 0; 1562 } 1563 1564 static int rt712_sdca_pcm_hw_free(struct snd_pcm_substream *substream, 1565 struct snd_soc_dai *dai) 1566 { 1567 struct snd_soc_component *component = dai->component; 1568 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component); 1569 struct sdw_stream_runtime *sdw_stream = 1570 snd_soc_dai_get_dma_data(dai, substream); 1571 1572 if (!rt712->slave) 1573 return -EINVAL; 1574 1575 sdw_stream_remove_slave(rt712->slave, sdw_stream); 1576 return 0; 1577 } 1578 1579 #define RT712_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ 1580 SNDRV_PCM_RATE_192000) 1581 #define RT712_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \ 1582 SNDRV_PCM_FMTBIT_S24_LE) 1583 1584 static const struct snd_soc_dai_ops rt712_sdca_ops = { 1585 .hw_params = rt712_sdca_pcm_hw_params, 1586 .hw_free = rt712_sdca_pcm_hw_free, 1587 .set_stream = rt712_sdca_set_sdw_stream, 1588 .shutdown = rt712_sdca_shutdown, 1589 }; 1590 1591 static struct snd_soc_dai_driver rt712_sdca_dai[] = { 1592 { 1593 .name = "rt712-sdca-aif1", 1594 .id = RT712_AIF1, 1595 .playback = { 1596 .stream_name = "DP1 Playback", 1597 .channels_min = 1, 1598 .channels_max = 2, 1599 .rates = RT712_STEREO_RATES, 1600 .formats = RT712_FORMATS, 1601 }, 1602 .capture = { 1603 .stream_name = "DP4 Capture", 1604 .channels_min = 1, 1605 .channels_max = 2, 1606 .rates = RT712_STEREO_RATES, 1607 .formats = RT712_FORMATS, 1608 }, 1609 .ops = &rt712_sdca_ops, 1610 }, 1611 { 1612 .name = "rt712-sdca-aif2", 1613 .id = RT712_AIF2, 1614 .playback = { 1615 .stream_name = "DP3 Playback", 1616 .channels_min = 1, 1617 .channels_max = 2, 1618 .rates = RT712_STEREO_RATES, 1619 .formats = RT712_FORMATS, 1620 }, 1621 .ops = &rt712_sdca_ops, 1622 } 1623 }; 1624 1625 static struct snd_soc_dai_driver rt712_sdca_dmic_dai[] = { 1626 { 1627 .name = "rt712-sdca-aif3", 1628 .id = RT712_AIF3, 1629 .capture = { 1630 .stream_name = "DP8 Capture", 1631 .channels_min = 1, 1632 .channels_max = 4, 1633 .rates = RT712_STEREO_RATES, 1634 .formats = RT712_FORMATS, 1635 }, 1636 .ops = &rt712_sdca_ops, 1637 } 1638 }; 1639 1640 int rt712_sdca_init(struct device *dev, struct regmap *regmap, 1641 struct regmap *mbq_regmap, struct sdw_slave *slave) 1642 { 1643 struct rt712_sdca_priv *rt712; 1644 int ret; 1645 1646 rt712 = devm_kzalloc(dev, sizeof(*rt712), GFP_KERNEL); 1647 if (!rt712) 1648 return -ENOMEM; 1649 1650 dev_set_drvdata(dev, rt712); 1651 rt712->slave = slave; 1652 rt712->regmap = regmap; 1653 rt712->mbq_regmap = mbq_regmap; 1654 1655 regcache_cache_only(rt712->regmap, true); 1656 regcache_cache_only(rt712->mbq_regmap, true); 1657 1658 mutex_init(&rt712->calibrate_mutex); 1659 mutex_init(&rt712->disable_irq_lock); 1660 1661 INIT_DELAYED_WORK(&rt712->jack_detect_work, rt712_sdca_jack_detect_handler); 1662 INIT_DELAYED_WORK(&rt712->jack_btn_check_work, rt712_sdca_btn_check_handler); 1663 1664 /* 1665 * Mark hw_init to false 1666 * HW init will be performed when device reports present 1667 */ 1668 rt712->hw_init = false; 1669 rt712->first_hw_init = false; 1670 rt712->fu0f_dapm_mute = true; 1671 rt712->fu0f_mixer_l_mute = rt712->fu0f_mixer_r_mute = true; 1672 rt712->fu1e_dapm_mute = true; 1673 rt712->fu1e_mixer_mute[0] = rt712->fu1e_mixer_mute[1] = 1674 rt712->fu1e_mixer_mute[2] = rt712->fu1e_mixer_mute[3] = true; 1675 rt712->fu05_dapm_mute = true; 1676 rt712->fu05_mixer_l_mute = rt712->fu05_mixer_r_mute = false; 1677 1678 /* JD source uses JD1 in default */ 1679 rt712->jd_src = RT712_JD1; 1680 1681 if (slave->id.part_id != RT712_PART_ID_713) 1682 ret = devm_snd_soc_register_component(dev, 1683 &soc_sdca_dev_rt712, rt712_sdca_dai, ARRAY_SIZE(rt712_sdca_dai)); 1684 else 1685 ret = devm_snd_soc_register_component(dev, 1686 &soc_sdca_dev_rt712, rt712_sdca_dai, 1); 1687 if (ret < 0) 1688 return ret; 1689 1690 /* only add the dmic component if a SMART_MIC function is exposed in ACPI */ 1691 if (sdca_device_quirk_match(slave, SDCA_QUIRKS_RT712_VB)) { 1692 ret = devm_snd_soc_register_component(dev, 1693 &soc_sdca_dev_rt712_dmic, 1694 rt712_sdca_dmic_dai, 1695 ARRAY_SIZE(rt712_sdca_dmic_dai)); 1696 if (ret < 0) 1697 return ret; 1698 rt712->dmic_function_found = true; 1699 } 1700 1701 /* set autosuspend parameters */ 1702 pm_runtime_set_autosuspend_delay(dev, 3000); 1703 pm_runtime_use_autosuspend(dev); 1704 1705 /* make sure the device does not suspend immediately */ 1706 pm_runtime_mark_last_busy(dev); 1707 1708 pm_runtime_enable(dev); 1709 1710 /* important note: the device is NOT tagged as 'active' and will remain 1711 * 'suspended' until the hardware is enumerated/initialized. This is required 1712 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently 1713 * fail with -EACCESS because of race conditions between card creation and enumeration 1714 */ 1715 1716 dev_dbg(dev, "%s\n", __func__); 1717 1718 return 0; 1719 } 1720 1721 static void rt712_sdca_va_io_init(struct rt712_sdca_priv *rt712) 1722 { 1723 int ret = 0; 1724 unsigned int hibernation_flag; 1725 struct device *dev = &rt712->slave->dev; 1726 1727 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_ANALOG_BIAS_CTL3, 0xaa81); 1728 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_LDO2_3_CTL1, 0xa1e0); 1729 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL1, 0x0000); 1730 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL2, 0x0000); 1731 rt712_sdca_index_write(rt712, RT712_VENDOR_ANALOG_CTL, RT712_MISC_POWER_CTL7, 0x0000); 1732 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23); 1733 1734 /* calibration */ 1735 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, &hibernation_flag); 1736 if (!hibernation_flag) { 1737 ret = rt712_sdca_calibration(rt712); 1738 if (ret < 0) 1739 dev_err(dev, "%s, calibration failed!\n", __func__); 1740 } 1741 1742 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 1743 RT712_MIXER_CTL1, 0x3000, 0x0000); 1744 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, 1745 RT712_ADC0A_08_PDE_FLOAT_CTL, 0x1112); 1746 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, 1747 RT712_MIC2_LINE2_PDE_FLOAT_CTL, 0x3412); 1748 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, 1749 RT712_DAC03_HP_PDE_FLOAT_CTL, 0x4040); 1750 1751 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 1752 RT712_HDA_LEGACY_GPIO_WAKE_EN_CTL, 0x0001, 0x0000); 1753 regmap_write(rt712->regmap, 0x2f50, 0x00); 1754 regmap_write(rt712->regmap, 0x2f54, 0x00); 1755 regmap_write(rt712->regmap, 1756 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_IT09, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01); 1757 1758 /* add SPK settings */ 1759 if (rt712->hw_id != RT712_DEV_ID_713) { 1760 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_AMP_PDE_FLOAT_CTL, 0x2323); 1761 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_EAPD_CTL, 0x0002); 1762 regmap_write(rt712->regmap, 1763 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_OT23, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x04); 1764 } 1765 } 1766 1767 static void rt712_sdca_vb_io_init(struct rt712_sdca_priv *rt712) 1768 { 1769 int ret = 0; 1770 unsigned int jack_func_status, mic_func_status, amp_func_status; 1771 struct device *dev = &rt712->slave->dev; 1772 1773 regmap_read(rt712->regmap, 1774 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &jack_func_status); 1775 regmap_read(rt712->regmap, 1776 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &mic_func_status); 1777 regmap_read(rt712->regmap, 1778 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &_func_status); 1779 dev_dbg(dev, "%s jack/mic/amp func_status=0x%x, 0x%x, 0x%x\n", 1780 __func__, jack_func_status, mic_func_status, amp_func_status); 1781 1782 /* DMIC */ 1783 if ((mic_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) { 1784 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_DMIC2_FU_IT_FLOAT_CTL, 0x1526); 1785 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_DMIC2_FU_CH12_FLOAT_CTL, 0x0304); 1786 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_ADC0A_CS_ADC0B_FU_FLOAT_CTL, 0x1f1e); 1787 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_ADC0B_FU_CH12_FLOAT_CTL, 0x0304); 1788 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_HDA_LEGACY_CONFIG_CTL0, 0x8010); 1789 regmap_write(rt712->regmap, 1790 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_IT11, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01); 1791 rt712_sdca_index_write(rt712, RT712_ULTRA_SOUND_DET, RT712_ULTRA_SOUND_DETECTOR6, 0x3200); 1792 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23); 1793 1794 /* clear flag */ 1795 regmap_write(rt712->regmap, 1796 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), 1797 FUNCTION_NEEDS_INITIALIZATION); 1798 } 1799 1800 /* Jack */ 1801 if ((jack_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) { 1802 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_SEL_VEE2_HP_CTL1, 0x042a); 1803 rt712_sdca_index_write(rt712, RT712_CHARGE_PUMP, RT712_HP_DET_CTL3, 0x1fff); 1804 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_IO_CTL, 0xec67); 1805 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_ANALOG_BIAS_CTL3, 0xaa81); 1806 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_LDO2_3_CTL1, 0xa1e0); 1807 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL1, 0x0000); 1808 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL2, 0x0000); 1809 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23); 1810 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_JD_CTL1, 0x2802); 1811 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CLASSD_AMP_CTL6, 0xf215); 1812 1813 /* calibration */ 1814 ret = rt712_sdca_calibration(rt712); 1815 if (ret < 0) 1816 dev_err(dev, "%s, calibration failed!\n", __func__); 1817 1818 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, 0x3000, 0x0000); 1819 regmap_write(rt712->regmap, 1820 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_IT09, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01); 1821 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_MISC_CTL_FOR_UAJ, 0x0003); 1822 1823 /* clear flag */ 1824 regmap_write(rt712->regmap, 1825 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), 1826 FUNCTION_NEEDS_INITIALIZATION); 1827 } 1828 1829 /* SPK */ 1830 if ((amp_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) { 1831 if (rt712->hw_id != RT712_DEV_ID_713) { 1832 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_IO_CTL, 0xec63); 1833 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CLASSD_AMP_CTL1, 0xfff5); 1834 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_EAPD_CTL, 0x0002); 1835 regmap_write(rt712->regmap, 1836 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_OT23, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x04); 1837 } 1838 /* clear flag */ 1839 regmap_write(rt712->regmap, 1840 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), 1841 FUNCTION_NEEDS_INITIALIZATION); 1842 } 1843 } 1844 1845 static void rt712_sdca_reset(struct rt712_sdca_priv *rt712) 1846 { 1847 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_REG, 1848 RT712_PARA_VERB_CTL, RT712_HIDDEN_REG_SW_RESET, 1849 RT712_HIDDEN_REG_SW_RESET); 1850 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, 1851 RT712_HDA_LEGACY_RESET_CTL, 0x1, 0x1); 1852 } 1853 1854 int rt712_sdca_io_init(struct device *dev, struct sdw_slave *slave) 1855 { 1856 struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev); 1857 unsigned int val; 1858 struct sdw_slave_prop *prop = &slave->prop; 1859 1860 rt712->disable_irq = false; 1861 1862 if (rt712->hw_init) 1863 return 0; 1864 1865 regcache_cache_only(rt712->regmap, false); 1866 regcache_cache_only(rt712->mbq_regmap, false); 1867 if (rt712->first_hw_init) { 1868 regcache_cache_bypass(rt712->regmap, true); 1869 regcache_cache_bypass(rt712->mbq_regmap, true); 1870 } else { 1871 /* 1872 * PM runtime status is marked as 'active' only when a Slave reports as Attached 1873 */ 1874 1875 /* update count of parent 'active' children */ 1876 pm_runtime_set_active(&slave->dev); 1877 } 1878 1879 pm_runtime_get_noresume(&slave->dev); 1880 1881 rt712_sdca_reset(rt712); 1882 1883 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_JD_PRODUCT_NUM, &val); 1884 rt712->hw_id = (val & 0xf000) >> 12; 1885 rt712->version_id = (val & 0x0f00) >> 8; 1886 dev_dbg(&slave->dev, "%s hw_id=0x%x, version_id=0x%x\n", __func__, rt712->hw_id, rt712->version_id); 1887 1888 if (rt712->version_id == RT712_VA) { 1889 if (rt712->dmic_function_found) { 1890 dev_err(&slave->dev, "%s RT712 VA detected but SMART_MIC function exposed in ACPI\n", 1891 __func__); 1892 goto suspend; 1893 } 1894 1895 rt712_sdca_va_io_init(rt712); 1896 } else { 1897 if (!rt712->dmic_function_found) 1898 dev_warn(&slave->dev, "%s RT712 VB detected but no SMART_MIC function exposed in ACPI\n", 1899 __func__); 1900 1901 /* multilanes and DMIC are supported by rt712vb */ 1902 prop->lane_control_support = true; 1903 rt712_sdca_vb_io_init(rt712); 1904 } 1905 1906 /* 1907 * if set_jack callback occurred early than io_init, 1908 * we set up the jack detection function now 1909 */ 1910 if (rt712->hs_jack) 1911 rt712_sdca_jack_init(rt712); 1912 1913 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, 0x0001); 1914 1915 if (rt712->first_hw_init) { 1916 regcache_cache_bypass(rt712->regmap, false); 1917 regcache_mark_dirty(rt712->regmap); 1918 regcache_cache_bypass(rt712->mbq_regmap, false); 1919 regcache_mark_dirty(rt712->mbq_regmap); 1920 } else 1921 rt712->first_hw_init = true; 1922 1923 /* Mark Slave initialization complete */ 1924 rt712->hw_init = true; 1925 1926 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1927 1928 suspend: 1929 pm_runtime_put_autosuspend(&slave->dev); 1930 1931 return 0; 1932 } 1933 1934 MODULE_DESCRIPTION("ASoC RT712 SDCA SDW driver"); 1935 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1936 MODULE_LICENSE("GPL"); 1937