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